反向造型

Question

最近开发中遇到一个问题，关于“反向造型”。 
Java代码 
package workflow.fun_logic;    
  
public interface IFunLogic {    
    public boolean logic(Object arg1 , Object arg2);    
}    
    
    
package workflow.fun_logic;    
    
public class FunLogic_is implements IFunLogic {    
    
    public boolean logic(Object arg1, Object arg2) {    
    
/*  
将arg1，arg2还原，去调用logic(String arg1, String arg2) or logic(Integer arg1, Integer arg2);？？？？ 
*/    
  
        return logic(arg1,arg2);    
            
    }    
        
    public boolean logic(String arg1, String arg2) {    
            
        if(null == arg1){return false;}    
        if(null == arg2){return false;}    
            
        return arg1.equals(arg2);    
    }    
        
    public boolean logic(Integer arg1, Integer arg2) {    
            
        if(null == arg1){return false;}    
        if(null == arg2){return false;}    
            
        return arg1.intValue() == arg2.intValue();    
    }    
        
}    
    
//测试    
package workflow.fun_logic;    
    
public class text {    
    public static void main(String[] arg){    
            
        IFunLogic obj = new FunLogic_is();    
            
        System.out.println(obj.logic("q","q")); //调用logic(String arg1, String arg2)   
            
    }    
        
}    

Answer 1

分为3种情况：
第一种
方法在调用的时候，会去找最相近的类型，这个和多态没有关系public class Test { 
    public Test(Object o) {
        System.out.println("1"); 
    } 
    public Test(String a) {
        System.out.println("2"); 
    } 
    public static void main(String args[]) {
        new Test("123"); 
    } 
}答案是2
第二种
但是如果改成new Test(null);public class Test {
    public Test(Object o) {
        System.out.println("1");
    } 
    public Test(String a) {
        System.out.println("2"); 
    } 
    public static void main(String args[]) {
        new Test(null); 
    } 
}如果两个类型，比如这里Object 和String有继承关系，按照向上原则，先匹配子类
第三种
如果没有继承关系那就完了，
比如    public class Test {
        public Test(Integer o) {
            System.out.println("1"); 
        } 
        public Test(String a) {
            System.out.println("2"); 
        } 
        public static void main(String args[]) {
            new Test(null); 
        } 
    }因为，这个函数可以匹配2个方法，且没有任何关系，就会产生编译错误（The constructor is ambiguous）构造函数有歧义 

Answer 2

我的意思是：如何将arg1，arg2动态还原

Answer 3

为什么非要起一样的名字？
根据Class信息得到类名，再根据类名来确定要调用的方法不可以吗？

Answer 4

public interface Test {
public boolean logic(Object arg1 , Object arg2);   
}public class TestCase implements Test {
public boolean logic(Object arg1, Object arg2) {
if (arg1 instanceof String && arg2 instanceof String) {
return logic((String)arg1, (String)arg2);
}
else if (arg1 instanceof Integer && arg2 instanceof Integer) {
return logic((Integer)arg1, (Integer)arg2);
}
return false;
} public boolean logic(String arg1, String arg2) { if (null == arg1) {
return false;
}
if (null == arg2) {
return false;
} return arg1.equals(arg2);
} public boolean logic(Integer arg1, Integer arg2) { if (null == arg1) {
return false;
}
if (null == arg2) {
return false;
} return arg1.intValue() == arg2.intValue();
}

public static void main(String args[]) {
Test test = new TestCase();
System.out.println(test.logic("a", "b"));
}
}这是google，叫Grace得框架的做法

Answer 5

可以改接口的话这样写得了：
public interface IFunLogic {    
    public <T> boolean logic(T arg1 , T arg2);    
}  

Answer 6

刚才写的代码是Guice框架里面用的方法

Answer 7

如果只是调用String 和Integer的两个方法何必如此通过Object中转呢，直接让它自己匹配不就行了