Question

我有一个实用程序类OldRemote，现在已经弃用了，但仍然会使用一段时间，直到新的类NewRemote稳定为止。这两个实用程序类具有相同的方法名称和参数，但是返回类型pojo类不同。即使返回类型pojo结构相同，但命名也不同。

简单来说，两种函数返回类型都是具有不同字段名称的pojo。

在用例以下是否有任何通用的方法来处理此问题？

我创建了一个服务接口，该接口具有新旧类的通用方法协定。

public interface RemoteService {

    //contract [ return type is object to receive all/any Pojo classes ]
    Object turnOnTV();

    static Service GetRemoteservice(boolean isOldRemote){
        if(isOldRemote){
            return new OldRemote();
        }
        return new NewRemote();
    }
}

OldRemote类

public class OldRemote implements RemoteService{
    @Override
    public OldPojo turnOnTV() {
        OldPojo oldPojo = new OldPojo();
        System.out.println("OldPojo");
        return oldPojo;
    }
}

NewRemote类

public class NewRemote implements Service{
    @Override
    public NewPojo turnOnTV() {
        NewPojo newPojo = new NewPojo();
        System.out.println("NewPojo");
        return newPojo;
    }
}

上述实现的演示用法。

public class DemoTvRemote {
    public static void main(String[] args) {

        RemoteService remoteService1 = RemoteService.GetRemoteservice(true);
        OldPojo oldRemote = (OldPojo) remoteService1.turnOnTV();

        RemoteService remoteService2 = RemoteService.GetRemoteservice(false);
        NewPojo shr = (NewPojo) Service2.test();
    }
}

上面的代码可以正常工作。但是问题是我不想在整个代码库中所有使用turnOnTV()的地方都键入强制类型转换。即使必须这样做，也必须编写一个条件来在OldPojo被调用的NewPojo和turnOnTV()之间切换。

有什么办法解决这个问题？

Answer 1

您可以创建它们都可以扩展/实现的基类或接口。

public abstract class RemoteServiceBase<E> {
    public abstract E turnOnTv();
}

public class NewRemoteService extends RemoteServiceBase<NewRemotePojo >{
    public NewRemotePojo turnOnTv() {
         return new NewRemotePojo();
    } 
}


public class OldRemoteService extends RemoteServiceBase<OldRemotePojo >{
    public OldRemotePojo turnOnTv() {
         return new OldRemotePojo();
    } 
}

这仅在您知道服务类型的情况下仍然有效。否则，您将像期望的那样使用通用泛型类型。

Answer 2

我们可以通过以下方法处理此问题：

1）我们可以在公共位置创建一个虚拟POJO类，并同时引用OldPojo和NewPojo作为数据成员

public class CommonPojo  {

     OldPojo oldPojo;
     NewPojo newPojo; 

     public void setOldPojo(OldPojo oldPojo){
         this.oldPojo=oldPojo;
      }

      public void setNewPojo(NewPojo newPojo){
         this.newPojo=newPojo;
      }

     public OldPojo getOldPojo(){
         return oldPojo;
      }

      public NewPojo getNewPojo(){
         return newPojo;
      }
    }

2）我们可以编写如下的Utility方法，该方法可以给出commonpojo对象：

public class CommonRemote {


 public  static CommonPojo turnOnTv(Boolean isOldRemote){

    CommonPojo commonPojo = new CommonPojo  

    if(isOldRemote){
         OldPojo oldPojo =new OldPojo();
         commonPojo.setOldPojo(oldPojo);

       }else{
           NewPojo newPojo =new NewPojo();
           commonPojo.setNewPojo (newPojo);
       }

    }

}

3）使用以下方法作为turnOnTv（）：

public class DemoTvRemote {
    public static void main(String[] args) {

       CommonPojo remote1 = CommonRemote.turnOnTv(true);
        OldPojo oldRemote = remote1.getOldPojo();

       CommonPojo remote2 = CommonRemote.turnOnTv(false);
        NewPojo newRemote = remote2.getNewPojo();

    }
}

采用这种方法，代码几乎不需要更改，我们无需任何类型转换就可以满足您的要求。

Java-具有通用类型参数并在调用它时进行类型转换的重写方法

2 个答案: