有没有一种方法可以在Java中将布尔类型指定为泛型？

我有一个代码块，如下所示：

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泛型实现，但这看起来不可能

我知道这看起来和波利莫菲兹有关。但我不知道有人会这样想

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);

公共接口是高级的
呼叫（E型）
...
公共类NormalClass实现了ISupClass
...
公共类DailyClass实现了ISupClass
...
公共void调用（int类型，boolean-isDaily）{
高级呼叫（isDaily）；

（以防我理解问题所在）

这就是使用接口的要点。只需执行以下操作：

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());
    }
}

因此，在您的情况下，在

call

方法中传递参数

ISupClass

，而不是传递

boolean isDaily

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

现在，泛型是一个完全不同的故事，我不知道它与这个问题有什么关系。

（以防我理解了这个问题）

这就是使用接口的要点。只需执行以下操作：

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());
    }
}

因此，在您的情况下，在

call

方法中传递参数

ISupClass

，而不是传递

boolean isDaily

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

---

现在，泛型是一个完全不同的故事，我不知道它与这个问题有什么关系。

据我所知，

public void call（int-type，boolean-isDaily）{…}

是一个编排器/中介器方法，它根据参数中接收到的标志操纵一个或另一个实例。
在这种情况下，为什么不使用

映射

存储这两个实例，以便从布尔键检索它们：

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();
  }
}

Map Map=newhashmap（）；
put（Boolean.TRUE，newdailyclass（））；
put（Boolean.FALSE，new NormalClass（））；
//...
公共void调用（int类型，boolean-isDaily）{
非规范类obj=map.get（isDaily）；
如果（类型==0）{
obj.call（）；
}
如果（类型==1）{
obj.call1（）；
}
}

据我所知，

public void call（int-type，boolean-isDaily）{…}

是一种编排器/中介器方法，它根据参数中接收到的标志操纵一个或另一个实例。
在这种情况下，为什么不使用

映射

存储这两个实例，以便从布尔键检索它们：

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();
  }
}

Map Map=newhashmap（）；
put（Boolean.TRUE，newdailyclass（））；
put（Boolean.FALSE，new NormalClass（））；
//...
公共void调用（int类型，boolean-isDaily）{
非规范类obj=map.get（isDaily）；
如果（类型==0）{
obj.call（）；
}
如果（类型==1）{
obj.call1（）；
}
}

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

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);
    }
}

---

您可以将默认方法添加到接口：

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);
    }
}

---

对我来说，你的问题还不清楚。你所说的“逃避isDaily检查”是什么意思？你能分享一下你的泛型方法吗？你试过使用包装类吗？你能用自己的话描述一下你想要它做什么吗？你想在这里学习多态性，而不是泛型。这就是OOP的本质：“相同”的能力方法在继承的基础上做了不同的事情。@Turing85，我刚刚把它编辑成我所说的“泛型方法”和“从isDaily中退出”的意思。对我来说，你的问题还不清楚。“从isDaily检查中退出”是什么意思？你能分享一下你的泛型方法吗？你试过使用包装类吗？你能用你自己的话描述一下你想要它做什么吗？你想在这里学习多态性，而不是泛型。这就是OOP的本质：“相同”的能力方法在继承的基础上做了不同的事情。@Turing85，我刚刚编辑了它，正如我所说的“泛型方法”和“从isDaily中退出”。在方法中传递依赖项在我看来并不合适。您可以在构造类的对象时提供这些依赖项，其中

调用（int-type）

defined@AndrewTobilko我并不反对，但我认为问题是……“如何避免使用

isDaily

check”。我不认为在答案中包含此类信息会有帮助。我的意思是，这也是一个完全不同的故事。在方法中传递依赖项在我看来并不合适。您可以在构造类的对象时提供这些依赖项，其中

调用（int type）

defined@AndrewTobilko我并不反对，但我认为问题是……“如何避免使用

isDaily

check”。我不认为在答案中包含此类信息会有帮助。我的意思是，这也是一个完全不同的故事。