如何限制java接口在多个类中实现

Question

I need to develop interface which can be implemented only once. If other class try to implement same interface in same project then it should not be allowed or give an error.

interface A {
   void someMethod();
}

class B implements A {
    void someMethod() {
        // implementation here
    }
}

Now I want to restrict other classes to implement interface A

class c implements A { //this  should not allowed in this project
}

Is it possible to develop this kind of interface? Can anyone suggest, how can I go through to achieve this?

Answer 1

简单的回答，如果你的界面是公共/包受保护的，那就不可能了。

Answer 2

This defeats the purpose of an interface. If you're only going to have one implementation, it may as well be concrete.

Interfaces are meant to be implemented by multiple classes. This allows you to switch out implementations without having to worry about their implementation details. For example, the most common use of interfaces is with the collections framework, particularly List , Set , and Map .

// Hides the implementation details of ArrayList within a List variable
List<String> strs = new ArrayList<String>();
// Hides the implementation details of LinkedList within the same List variable
strs = new LinkedList<String>();
// All code using strs is agnostic to what kind of list it is (mostly)
strs.add("Hello, Dolly");
System.out.println(strs.get(0));

Interfaces primarily embody two OOP concepts: encapsulation and polymorphism . If you don't plan on using your interface to accomplish one of these two things, don't use an interface. Just use a concrete (non-abstract) class. Using an interface at this point is overkill.

Only exception to this rule I can think of is when you want to use Java's Proxy class. Only then is a 1:1 interface:class ratio acceptable since you have to have an interface to wrap the implementation in the Proxy instance.

Answer 3

It sounds like your design is wrong, and that your interface should actually just be part of class B .

The point of an interface is that it allows different implementations of the same set of methods, which you are trying to avoid here.

Answer 4

Put your interface A with class B in same package.

All the classes which should not implement A , should be outside this package.

Answer 5

The only global way to know about implementations of A is if they register themselves to you, which is pointless, you can forget about that.

---

I'm not sure if you require that all instances of A that you work with have a common class besides Object.class , or that their class is the same, or that their class is B.class .

Regardless of what you want to enforce, you need to test for undesirable situations on instances of A that you get passed, you have no business with instances of A that you don't work with anyway.

Alternatively, for every instance of A you get passed, you could create a new B and insert the data that you need from the passed A .

---

But first, you should think about why you want this, chances are it's not really a problem when there are different implementations of A .