Question

我正在开发一个系统，该系统需要高峰时的性能，而且我遇到了一个我想问的解决方案。

这是我的代码

public interface ILoad {
    public void loadData();
}

public class ClassOne implements ILoad {
    @Override
    public void loadData() {
        System.out.println("CLASS ONE LOADING DATA ");
    }
}

public class ClassTwo implements ILoad {
    @Override
    public void loadData() {
        System.out.println("CLASS TWO LOADING DATA");
    }
}

public static void main(String[] args) {
    load(new ClassOne());
    load(new ClassTwo());
}

public static void load(Object o){
    ILoad ref = (ILoad) o;
    ref.loadData();
}

正如您在上面的情况中所看到的，没有if else或switch条件，所有代码都是通过引用使用接口执行的，这在编程时非常快。

我的问题是我的界面有两种方法loadData()和loadRecord()

现在，如果我想执行这两个方法，就像上面的示例一样，我该怎么做？一种方法是制作一个单独的类，第二种方式是反思和内省。有没有更好的解决方案？

Answer 1

你为什么不这样做：

   public static void load(ILoad o){ // both classes implement Iload. using Object here gives a chance for anything to come here.
    o.loadData();
}

Answer 2

如果必须强制转换，则不能正确使用多态。

这样的事情怎么样？

public static interface ILoadData {

    public void loadData();
}

public static interface ILoadRecord {

    public void loadRecord();
}

public static interface ILoadEither extends ILoadData, ILoadRecord {
}

public static class ClassOne implements ILoadData {

    @Override
    public void loadData() {
        System.out.println("CLASS ONE LOADING DATA ");
    }
}

public static class ClassTwo implements ILoadData {

    @Override
    public void loadData() {
        System.out.println("CLASS TWO LOADING DATA");
    }
}

public static class ClassThree implements ILoadRecord {

    @Override
    public void loadRecord() {
        System.out.println("CLASS THREE LOADING RECORD");
    }
}

public static class ClassFour implements ILoadRecord, ILoadData {

    @Override
    public void loadRecord() {
        System.out.println("CLASS FOUR LOADING RECORD");
    }

    @Override
    public void loadData() {
        System.out.println("CLASS FOUR LOADING DATA");
    }
}

public static class ClassFive implements ILoadEither {

    @Override
    public void loadRecord() {
        System.out.println("CLASS FIVE LOADING RECORD");
    }

    @Override
    public void loadData() {
        System.out.println("CLASS FIVE LOADING DATA");
    }
}

public static void load(ILoadData o) {
    o.loadData();
}

public static void load(ILoadRecord o) {
    o.loadRecord();
}

public static void load(ILoadEither o) {
    o.loadRecord();
}

public static void main(String[] args) {
    load(new ClassOne());
    load(new ClassTwo());
    load(new ClassThree());
    load((ILoadData)new ClassFour());
    load((ILoadRecord)new ClassFour());
    load(new ClassFive());
}

这里我们有多个static load方法，每个方法都使用不同接口的参数，但编译器可以在编译时决定使用哪个，除非它不明确，在这种情况下你需要一些其他技巧 - 我使用在这里进行转换很简单，但你最好使用某种适配器。

Answer 3

我不确定我是否理解了您的问题，但是以下代码还不够？

public interface ILoad {

   public void loadData();
   public void loadRecord();
}

public class ClassOne implements ILoad{

   @Override
   public void loadData() {
      System.out.println("CLASS ONE LOADING DATA ");
   }

   @Override
   public void loadRecord() {
      System.out.println("CLASS ONE LOADING RECORD");
   }

}

public class ClassTwo implements ILoad{

   @Override
   public void loadData() {
      System.out.println("CLASS TWO LOADING DATA ");
   }

   @Override
   public void loadRecord() {
      System.out.println("CLASS TWO LOADING RECORD");
   }

}

public static void main(String[] args) {
   // TODO code application logic here
   load(new ClassOne());
   load(new ClassTwo());

   //new objects created here, instances can be created just once
   loadRecord(new ClassOne());
   loadRecord(new ClassTwo());
}

public static void load(ILoad l){
   ref.loadData();
}

public static void loadRecord(ILoad l){
   ref.loadRecord();
}

Java多态与动态规划

3 个答案: