Question

我有如下代码块：

public Interface ISupClass{
   void call();
   void call1();
   ...
}

public class NormalClass implements ISupClass{
   void call(){
     ....operations...
   }
   void call1(){
     ....operations...
   }
   ...
}

public class DailyClass implements ISupClass{
   void call(){
     ....operations...
   }
   void call1(){
     ....operations...
   }
   ...
}

然后我从这样的主要服务中称呼他们

实例：

private INormalClass dailyClass = new DailyClass();
private INormalClass normalClass = new NormalClass();

方法：

public void call(int type, boolean isDaily){
  if(type == 0) {
   if(isDaily){
     dailyClass.call();
   }
   else{
    normalClass.call();
   }
  }
  if(type == 1) {
   if(isDaily){
     dailyClass.call1();
   }
   else{
    normalClass.call1();
   }
  }
  ...
}

是否有一种方法可以退出isDaily上面的代码块？或者如何有效实施？我刚刚尝试用Java泛型实现，但这看起来不可能吗？

我知道这看起来与polimorfizm有关。但我想知道是否有人对此感兴趣；

public Interface ISupClass<E>
  call(E type)
...
public class NormalClass implements ISupClass<Boolen.FALSE>
...
public class DailyClass implements ISupClass<Boolen.TRUE>
...
public void call(int type, boolean isDaily){
   supClass.call(isDaily);

Answer 1

（如果我理解了问题所在）

这是使用接口的重点。只需执行以下操作即可：

public class Example {
    public static interface ISupClass {
        void doSomething();
    }

    public static class NormalClass implements ISupClass {

        @Override
        public void doSomething() {
            System.out.println("I am a normal class.");
        }

    }

    public static class DailyClass implements ISupClass {

        @Override
        public void doSomething() {
            System.out.println("I am a daily class.");
        }

    }

    public static void doSomething(ISupClass clazz) {
        clazz.doSomething();
    }

    public static void main(String[] args) {
        doSomething(new DailyClass());
        doSomething(new NormalClass());
    }
}

因此，在您的情况下，不要通过boolean isDaily方法传递参数ISupClass来传递call。

public void call(int type, ISupClass caller) {
    caller.call();
}

现在，泛型是一个完全不同的故事，我看不到它与问题之间的关系。

Answer 2

据我了解，public void call(int type, boolean isDaily){...}是一种编排器/调解器方法，它根据参数中接收到的标志来操纵一个或另一个实例。
在这种情况下，为什么不使用Map<Boolean, INormalClass>来存储两个实例，您可以从布尔键中检索它们：

Map<Boolean, INormalClass> map = new HashMap<>();
map.put(Boolean.TRUE, new DailyClass());
map.put(Boolean.FALSE, new NormalClass());
//...

public void call(int type, boolean isDaily){
  INormalClass obj = map.get(isDaily);
  if(type == 0) {
    obj.call();
  }
  if(type == 1) {
    obj.call1();
  }
}

Answer 3

您可以在界面中添加默认方法：

public interface ISupClass {

    default void call(int type) {
        if (type == 0) {
            call();
        } else if(type == 1) {
             call1();        
        }
    }
    void call();
    void call1();
}

它将引导您转到以下代码：

public static void call(int type, boolean isDaily) {
    if (isDaily) {
        dailyClass.call(type);
    } else {
        normalClass.call(type);
    }
}

有没有一种方法可以将布尔类型赋予Java中的泛型？

3 个答案: