java - 当类名称为字符串时转换为未知类型

Question

public class ExampleClass {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Horse hr1 = new Horse();
        Horse hr2 = new Horse();
        Horse hr3 = new Horse();
        Horse hr4 = new Horse();
        Set hrSet = new HashSet();
        hrSet.add(hr1);
        hrSet.add(hr2);
        hrSet.add(hr3);
        hrSet.add(hr4);
        Horse hr;
        String hor = "sher_pkg.Horse";
        callHorse(hrSet,hor);
    }
    public static void callHorse(Set xSet,String clsName){
        try {
            Class hrt = Class.forName(clsName);

            Iterator hritr = xSet.iterator();
            while(hritr.hasNext()){
                exam(hrt.cast(hritr.next()));
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static void exam(Object obj){ //I want to use exam(Horse hrr)
        System.out.println(obj);
    }
}

这里，考试函数的参数是一个对象。但我想让参数是Horse...那么在“exam(hrt.cast(hritr.next()))”方法调用中必须进行哪些更改？我不想在 callHorse() 中显式使用类名 Horse...那么我应该做什么？

谢谢

Answer 1

注意:带有“if (x instanceof MyClass)”序列的代码通常表明您没有充分使用多态性。通常可以重构代码以消除对此进行测试的需要。但我为了回答所提出的问题，将忽略这一点。

您可以做您想做的事情，但不能不更改一些代码。方法重载不能满足您的需要，因为在Java中，方法重载是在编译时决定的。因此，如果一个类中有两个方法，其中两个方法具有相同的名称、相同的返回类型，但参数类型不同，则调用此重载方法的任何代码都必须明确将调用哪一个方法。由于使用显式转换，您当前的代码使用它提供的类型执行此操作，但完全动态版本则不然。如果方法重载是在运行时决定的，那么您的代码将执行您想要的操作。但因为它是在编译时决定的，所以您的代码无法编译。

要解决您的问题，您可以使用泛型，也可以重构您的代码。首先，我将介绍一个测试工具，它显示了您开始使用的非常简化的版本:

public class Test {
  public void test(Object obj) {
    if (obj instanceof Horse) {
      Horse c = (Horse) obj;
      noise(c);
    }
    if (obj instanceof Cow) {
      Cow c = (Cow) obj;
      noise(c);
    }
  }

  public void noise(Horse h) {
    System.out.println("Neigh");
  }

  public void noise(Cow c) {
    System.out.println("Moo");
  }

  public static void main(String[] args) {
    Object o1 = new Horse();
    Object o2 = new Cow();
    Test tester = new Test();
    tester.test(o1);
    tester.test(o2);
  }
}

class Horse {}

class Cow {}

此代码运行并执行您所期望的操作。它打印“Neigh”，然后打印“Moo”。

您正在尝试替换

    if (obj instanceof Horse) {
      Horse c = (Horse) obj;
      noise(c);
    }

与

    if (obj instanceof Horse) {
      handleNoise(obj, Horse.class);
    }

然后添加处理它的方法(简化):

void handleNoise(Object obj, Class clazz) {
  noise(clazz.cast(obj));
}

正如我之前所说，这不起作用，噪声的重载是在编译时决定的。编译器看到您正在进行转换，但在编译时不知道类型是什么。因此它无法选择重载并且编译失败。

解决这个问题的最好方法是使用多态性，因为多态性是在运行时决定的。也就是说，让所有这些类实现某个接口(interface)，然后将有问题的代码移动到各个类中。下面是执行此操作的示例:

public class Test {
  public void test(Animal obj) {
    obj.noise();
  }

  public static void main(String[] args) {
    Animal o1 = new Horse();
    Animal o2 = new Cow();
    Test tester = new Test();
    tester.test(o1);
    tester.test(o2);
  }
}

interface Animal {
  void noise();
}

class Horse implements Animal {
  public void noise() {
    System.out.println("Neigh");
  }
}

class Cow implements Animal {
  public void noise() {
    System.out.println("Moo");
  }
}

注意测试方法是多么简单!如果您可以让每个项目实现一个接口(interface)来处理下面调用的 stringProp，那么您可以部分简化:

if (obj instanceof Cust) {
  loopOverSet(c.getCustPhonSet());
} else if (obj instanceof Name) {
  loopOverSet(c.getCustNameSet());
}
// and so on for the rest...

然后添加方法:

void loopOVerSet(Set cxSet) {
  if (cxSet != null && cxSet.size() > 0) {
    Iterator cxSetIterator = cxSet.iterator();
    while (cxSetIterator.hasNext())
    {
      ((StringProp)cxSetIterator.next()).stringProp();
    }
  }
}

这假设之前重载的方法 stringProp 已移至单独的类 CustPhone 和 CustName 等中，并且这些类它们都实现了一些我称之为 StringProp 的接口(interface)，其中该接口(interface)定义了 stringProp() 方法。由于此代码使用重写而不是重载，因此将在运行时决定。