是否可以使两个Java接口互斥？

Question

I have two interfaces that should exclude each other:

interface Animal{}
interface Cat extends Animal{}
interface Bird extends Animal{}

How can I prevent the implementation of a class that implements both Cat and Bird interfaces?

class Impossible implements Cat, Bird{}

Answer 1

Finally a dirty solution:

public interface Animal<BEING extends Animal> {}
public interface Cat extends Animal<Cat> {}
public interface Bird extends Animal<Bird> {}
public class CatBird implements Cat, Bird {} // compiler error
public interface CatBird extends Cat, Bird {} // compiler error

CatBird cant be implemented because:

The interface Animal cannot be implemented more than once with different arguments: Animal<Bird> and Animal<Cat>

Answer 2

Here you have a clear hierarchy - a root with branches, and clearly a node (class, interface, whatever) cannot be on more than one branch. In order to enforce this, use abstract classes instead of interfaces.

Interfaces may be used when there is some cross-cutting aspect which may be shared between any of the classes in your hierarchy, and where no two interfaces are mutually exclusive.

example:

public abstract class Animal;
public interface CanFly;
public interface CanHunt;
public abstract class Cat extends Animal implements CanHunt;
public abstract class Bird extends Animal implements CanFly;
public class Vulture extends Bird implements CanHunt; //also CanFly because of Bird

At least one other has considered this problem: http://instantbadger.blogspot.co.uk/2006/10/mutually-exclusive-interfaces.html

Answer 3

The interfaces in Java are born to be implemented. Any class can implement any interface as long as it wants. So, I think there is no way to prevent that case. You probably need reconsider your design.

Answer 4

There is a really, really ugly workaround. Implement a conflicting method signature to Cat and Bird interfaces:

public interface Cat {
    int x();
}

public interface Bird {
    float x();
}

/**
 * ERROR! Can not implement Cat and Bird because signatures for method x() differ!
 */
public class Impossible implements Cat, Bird {
}

But don't do this. Figure out a better way instead.

Answer 5

probably you can not prevent. maybe you can replace Cat and Bird by an abstract class and the Impossible can only extends one.

Answer 6

Not sure if this helps, but if you do not specify that the interface is public, your interface will be accessible only to classes defined in the same package as the interface.

So essentially, you could put your interface in one package, and any classes that you don't want to be able to implement it in another..

Answer 7

Java does not provide a piece of syntax that will prevent one class from implementing two different interfaces. This is a good thing, because interfaces are supposed to let you forget about exactly what object you're dealing with and focus on just the functionality associated with that interface.

In the case of animals this can seem confusing, because in real life no animal is both a cat and a dog. But there is no reason that one Java class cannot fulfil the contract of both a Cat interface and a Dog interface. If you want to ground this in reality, consider a box containing both a cat and a dog!

Now, as Torben and others point out, you can deliberately introduce methods into an interface that will clash with methods in the other interface. This will cause Java to forbid both interfaces being implemented in one class. But for the reasons listed above, this is not a good work-around to consider.

The best approach if you must force this relationship is the answer provided by NickJ .

Answer 8

You many throw an exception when a class is going to use it, the UML Diagram would like this

as you see in the above, the Possible would implement either Cat or Bird , but not both. but this is just a diagram, so the functionality would be like this.

interface Animal{void x();}
interface Cat extends Animal{}
interface Bird extends Animal{}
class Impossible implements Cat, Bird{

  @Override
  public void x() {
    System.out.println("Oops!");    
  }}

class Possible implements Cat{

  @Override
  public void x() {
    System.out.println("Blah blah");    
  }

}
class Core {
  private Animal a;
  public void setAnimal(Animal a) throws Exception {
    if (a instanceof Cat && a instanceof Bird) {
      System.out.println("Impossible!");
      throw new Exception("We do not accept magic");
    }
    this.a = a;
    a.x();
  }
  public static void main(String[] args) throws Exception {
    Core c = new Core();
    Possible p = new Possible();
    c.setAnimal(p);
    Impossible ip = new Impossible();
    c.setAnimal(ip);
  }
}