Java 函数使用依赖于两个不同包的对象

我将sama java对象TestData放在包（A&B）中。我创建了一个函数，用于处理标准业务功能的对象

CommonFunc.java:

import A.TestData ;
class CommonFunc
{
  ///  .....

    public static TestData processTestData(Date d1, String s1){

        TestData testData = new TestData ();

        /// set some testData  porperties based on d1 and s1
        /// e.g : testData.setInitialDate(d1);

        return testData ;
    }
}

这里的问题是编译器必须从其中一个包（比如包（A））加载对象，因此当我期望数据从包（B）返回到局部变量时，我会得到不兼容的类型错误：

使用B TestData的文件，需要调用函数processTestData：

import B.TestData;

// ...

TestData obj = CommonFunc.processTestData(new Date(), "test");

// ...

有没有办法克服这一问题，使两者保持一个共同的功能

有没有办法克服这一问题，使两者保持一个共同的功能

不，是的。在一般情况下，你不能

但是您可以，IFF您可以使两个类采用相同的接口，在相同的接口中声明公共方法。请参见下文，并对类名的更改表示歉意：

interface C {
  public Date getA();
  public void setA(Date a);

}
interface C_Factory <X extends C> {
  X createInstance();
}

class C1 implements C {
  Date a;
  int b;

  public C1() {
    super();
  }

  public Date getA() { return a;  }
  public void setA(Date a) {  this.a = a;  }


  public int getB() { return b; }
  public void setB(int b) {  this.b = b;  }
}

class C2 implements C {
  Date a;
  float b;

  public C2() {
    super();
  }

  public Date getA() { return a;  }
  public void setA(Date a) {  this.a = a; }


  public float getB() { return b; }
  public void setB(float b) {  this.b = b;  }
}

public class CommonFunc {
  // You need this extra param to create instances----
  //                                                 V
  static <X extends C> X doSomething(Date d, Class<X> clazz)
  throws InstantiationException, IllegalAccessException
  // You'll have to accept those exceptions as well
  {
    // the next statement uses clazz as a factory for new X instances
    // As such, you can abstract the method further and use
    // a custom Factory class instead.
    X toret=clazz.newInstance();
    toret.setA(d);
    // something else

    return toret;
  }

  // A custom factory variant of the above
  static <X extends C> X doSomething(Date d, C_Factory<X> factory)
  {
    X toret=factory.createInstance();
    toret.setA(d);
    // something else

    return toret;
  }

  static public void main(String[] args) {
    try {
      C1 c1=doSomething(new Date(), C1.class);
      C2 c2=doSomething(new Date(), C2.class);
    } catch (InstantiationException | IllegalAccessException e) {
      // Should not happen
      e.printStackTrace();
    }
  }
}

接口C{
公共日期getA（）；
公共无效setA（日期a）；
}
接口C_工厂{
X createInstance（）；
}
类C1实现C{
日期a；
int b；
公共C1（）{
超级（）；
}
public Date getA（）{return a；}
公共无效setA（日期a）{this.a=a；}
public int getB（）{return b；}
public void setB（int b）{this.b=b；}
}
C2类实现了C{
日期a；
浮球b；
公共C2（）{
超级（）；
}
public Date getA（）{return a；}
公共无效setA（日期a）{this.a=a；}
公共浮点getB（）{return b；}
public void setB（float b）{this.b=b；}
}
公共类CommonFunc{
//您需要这个额外的参数来创建实例----
//五
静态X剂量仪（日期d，类别）
抛出实例化异常，IllegalAccessException
//你也必须接受这些例外情况
{
//下一条语句使用clazz作为新X实例的工厂
//因此，您可以进一步抽象该方法并使用
//而是一个自定义的工厂类。
X toret=clazz.newInstance（）；
"毛"(d),；
//别的
返回托雷特；
}
//上述产品的定制工厂变体
静态X剂量测量（日期d，C_工厂）
{
X toret=factory.createInstance（）；
"毛"(d),；
//别的
返回托雷特；
}
静态公共void main（字符串[]args）{
试一试{
C1=剂量测定法（新日期（），C1.class）；
C2=剂量测定法（新日期（），C2.class）；
}捕获（实例化异常|非法访问异常e）{
//不应该发生
e、 printStackTrace（）；
}
}
}

我不认为在您发布的上述示例中，最好的解决方法是将TestData作为一个接口，并在两个包中实现。然后，为了决定是返回TestDataImpl还是返回B TestDataImpl，请在processData中获取另一个参数，为简单起见，让我们假设一个布尔值。基于true或false实例化TestDataImpl或B TestDataImpl并返回相同的值。其中processData的返回类型是接口类型

---

这可能是重用processData方法最直接的方法。

为什么有两个不同的

TestData

类？这是因为它是由两个不同的XSD自动生成的，它们似乎具有相似的元素