Java 将类限制为只接受任何一个接口实现，而不接受混合实现？

我有下面的类和接口

SuperInterface.java

public interface SuperInterface{/*some logic*/}

public interface SubOneInterface extends SuperInterface{/*some logic*/}

public interface SubTwoInterface extends SuperInterface{/*some logic*/}

SubOneInterface.java

public interface SuperInterface{/*some logic*/}

public interface SubOneInterface extends SuperInterface{/*some logic*/}

public interface SubTwoInterface extends SuperInterface{/*some logic*/}

SubTwoInterface.java

public interface SuperInterface{/*some logic*/}

public interface SubOneInterface extends SuperInterface{/*some logic*/}

public interface SubTwoInterface extends SuperInterface{/*some logic*/}

One.java

public class One{/*some logic*/}

2.java

public class Two{/*some logic*/}

SubOne.java

public class SubOne extends One implements SubOneInterface{/*some logic*/}

public class AnotherSubOne extends One implements SubTwoInterface{/*some logic*/}

AnotherSubOne.java

public class SubOne extends One implements SubOneInterface{/*some logic*/}

public class AnotherSubOne extends One implements SubTwoInterface{/*some logic*/}

SubTwo.java

public class SubTwo extends Two implements SubOneInterface{/*some logic*/}

public class AnotherSubTwo extends Two implements SubTwoInterface{/*some logic*/}

另一个subtwo.java

public class SubTwo extends Two implements SubOneInterface{/*some logic*/}

public class AnotherSubTwo extends Two implements SubTwoInterface{/*some logic*/}

现在，我必须编写一个类，该类将同时包含SubOneInterface和SubwoInterface的实现类

public class ClassesHolder{

 private List<One> one;
private List<Two> two;

//setters and getters

}

公共类文件夹{
私人名单一；
私人名单二；
//二传手和接球手
}

现在，

ClassesHolder

应该接受所有对象（One和Two的子类），这些对象实现了

子接口

或

子接口

，但不能同时实现这两个接口

如果他们试图用混合接口实现填充列表，那么应该抛出异常

---

我该怎么做呢？

您不能轻易排除实现特定接口的类。如果您的合同需求引用了

SubOneInterface

，那么它将接受实现

SubOneInterface

的类，而不管它们实现了什么

尝试其他方式似乎是一个糟糕的设计。如果您的

ClassesHolder

包含一个实现

子接口的类，那么它将引用该类，并且由于没有引用其他接口，任何其他功能都将被隐藏

你可以在列表之外检查你的课程

public void addToListOfOnes(final SubOneInterface obj) {
   if (obj instanceof SubTwoInterface) {
      // throw an exception
   } 
}

但这似乎很糟糕/违反直觉。我想退一步，再看看您的设计。
您不能轻易排除实现特定接口的类。如果您的合同需求引用了
SubOneInterface
，那么它将接受实现
SubOneInterface
的类，而不管它们实现了什么

尝试其他方式似乎是一个糟糕的设计。如果您的
ClassesHolder
包含一个实现
子接口的类，那么它将引用该类，并且由于没有引用其他接口，任何其他功能都将被隐藏

你可以在列表之外检查你的课程

public void addToListOfOnes(final SubOneInterface obj) {
   if (obj instanceof SubTwoInterface) {
      // throw an exception
   } 
}

但这似乎很糟糕/违反直觉。我想退一步，再看看您的设计。
您不能轻易排除实现特定接口的类。如果您的合同需求引用了
SubOneInterface
，那么它将接受实现
SubOneInterface
的类，而不管它们实现了什么

尝试其他方式似乎是一个糟糕的设计。如果您的
ClassesHolder
包含一个实现
子接口的类，那么它将引用该类，并且由于没有引用其他接口，任何其他功能都将被隐藏

你可以在列表之外检查你的课程

public void addToListOfOnes(final SubOneInterface obj) {
   if (obj instanceof SubTwoInterface) {
      // throw an exception
   } 
}

但这似乎很糟糕/违反直觉。我想退一步，再看看您的设计。
您不能轻易排除实现特定接口的类。如果您的合同需求引用了
SubOneInterface
，那么它将接受实现
SubOneInterface
的类，而不管它们实现了什么

尝试其他方式似乎是一个糟糕的设计。如果您的
ClassesHolder
包含一个实现
子接口的类，那么它将引用该类，并且由于没有引用其他接口，任何其他功能都将被隐藏

你可以在列表之外检查你的课程

public void addToListOfOnes(final SubOneInterface obj) {
   if (obj instanceof SubTwoInterface) {
      // throw an exception
   } 
}

但这似乎很糟糕/违反直觉。我想退一步，再看看你的设计。
看看我下面的例子。如果可以引入另一个接口作为接口的基本类型，那么此解决方案应该适用于您的应用程序。一旦实例化，它将不包括
One
的子类型或
Two
的子类型

public class Example {

    public static void main(String[] args) throws Exception {
        ClassesHolder<One> ones = new ClassesHolder<One>();
        ones.add(new SubOne());
        ones.add(new SubSubOne());
    }

}

interface Zero {}
interface One extends Zero {};
interface Two extends Zero {};
class SubOne implements One {};
class SubSubOne implements One {};
class SubTwo implements Two {};
class SubSubTwo implements Two {};

class ClassesHolder<V extends Zero> {
    public <T extends V> void add(T item) {}
}

公共类示例{
公共静态void main（字符串[]args）引发异常{
ClassesHolder one=新ClassesHolder（）；
添加（新子节点（））；
添加（新的子主题（））；
}
}
接口零{}
接口1扩展了零{}；
接口二扩展零{}；
类SubOne实现一个{}；
类SubSubOne实现一个{}；
类SubTwo实现两个{}；
类SubSubTwo实现两个{}；
课堂教师{
公共无效添加（T项）{}
}
看看我下面的例子。如果可以引入另一个接口作为接口的基本类型，那么此解决方案应该适用于您的应用程序。一旦实例化，它将不包括
One
的子类型或
Two
的子类型

public class Example {

    public static void main(String[] args) throws Exception {
        ClassesHolder<One> ones = new ClassesHolder<One>();
        ones.add(new SubOne());
        ones.add(new SubSubOne());
    }

}

interface Zero {}
interface One extends Zero {};
interface Two extends Zero {};
class SubOne implements One {};
class SubSubOne implements One {};
class SubTwo implements Two {};
class SubSubTwo implements Two {};

class ClassesHolder<V extends Zero> {
    public <T extends V> void add(T item) {}
}

公共类示例{
公共静态void main（字符串[]args）引发异常{
ClassesHolder one=新ClassesHolder（）；
添加（新子节点（））；
添加（新的子主题（））；
}
}
接口零{}
接口1扩展了零{}；
接口二扩展零{}；
类SubOne实现一个{}；
类SubSubOne实现一个{}；
类SubTwo实现两个{}；
类SubSubTwo实现两个{}；
课堂教师{
公共无效添加（T项）{}
}
看看我下面的例子。如果可以引入另一个接口作为接口的基本类型，那么此解决方案应该适用于您的应用程序。一旦实例化，它将不包括
One
的子类型或
Two
的子类型

public class Example {

    public static void main(String[] args) throws Exception {
        ClassesHolder<One> ones = new ClassesHolder<One>();
        ones.add(new SubOne());
        ones.add(new SubSubOne());
    }

}

interface Zero {}
interface One extends Zero {};
interface Two extends Zero {};
class SubOne implements One {};
class SubSubOne implements One {};
class SubTwo implements Two {};
class SubSubTwo implements Two {};

class ClassesHolder<V extends Zero> {
    public <T extends V> void add(T item) {}
}

公共类示例{
公共静态void main（字符串[]args）引发异常{
ClassesHolder one=新ClassesHolder（）；
添加（新子节点（））；
添加（新的子主题（））；
}
}
接口零{}
接口1扩展了零{}；
接口二扩展零{}；
类SubOne实现一个{}；
类SubSubOne实现一个{}；
类SubTwo实现两个{}；
苏类