Problem with multiple classes implements same interface

Question

I have trouble understanding when multiple classes implements same interface, before i was using concrete classes as DI but after searching and reading i was told that it should depend on abstaraction.So this is my problem:

interface SomeInterface{
    public void doSomething();
}

We have two classes that implements interface:

class FirstClass implements SomeInterface{

    @Override
    public void doSomething(){
        System.out.print("First class is doing something");
    }
}

class SecondClass implements SomeInterface {

    @Override
    public void doSomething() {
        System.out.print("Second class is doing something");
    }
}

And now i have a client where i want to use method from First and Second class:

class ClientClass {
    private SomeInterface someInterface;
  
    public ClientClass(SomeInterface someInterface) {
        this.someInterface = someInterface;
    }

    public void testMethod() {
        this.someInterface.doSomething();
    }
}

Now when i instantiate Client class i can only pass one class in constructor either first or second, and that method will start, but what if i want both method? What is wrong with this design?

I believe that the answer very much depends on your model. In some cases, it would be better to create few separate instances of the ClientClass and call testMethods independently or use design patterns like Composite in other cases — TiBi
– TiBi, Commented Aug 16, 2021 at 19:12
What is wrong with this design? - it's not wrong per se, just it can handle one SomeInterface at a time. If you need exactly two of them, you could use 2 member variables, and expect 2 arguments in the constructor. However if you need any amount of them, some List or perhaps Set would be a better way, and later you might need altering the collection of SomeInterfaces outside the constructor too. — tevemadar
– tevemadar, Commented Aug 16, 2021 at 20:51

Sergey Kalinichenko · Accepted Answer · 2021-08-16 19:01:31Z

1

You can use both methods, just not at the same time (unless you build another implementation that lets you make composite implementations).

For example, you can have different instances of ClientClass using different implementations of SomeInterface:

ClientClass clA = new ClientClass(new FirstClass());
ClientClass clB = new ClientClass(new SecondClass());

Now you have two objects, clA and clB, which have the same type, but different behavior, because they enclose a different instance of SomeInterface.

When you add DI (dependency injection) to the picture, you can write the code that makes ClientClass instances in a way that it has no knowledge of FirstClass or SecondClass, which lets you keep the client implementations independent of the SomeInterface hierarchy.

answered Aug 16, 2021 at 19:01

Sergey Kalinichenko

729k85 gold badges1.2k silver badges1.6k bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Nem Jov Over a year ago

Thanks for taking your time to write answer, but that didn't solve my problem, i can only have one instance of a Client class. Should i maybe have two separete interfaces for both classes? Or maybe some List? How would you solve this?

WJS · Accepted Answer · 2021-08-16 20:23:47Z

At least two of the advantages of an interface is to 1) provide abstract methods that could be implemented by more than one class to tie together common aspects of the implementing classes, and 2) to allow a mechanism by which those interfaces and others may be implemented by the same class (as opposed to a single inheritance model).

If your different classes have the same meaning and and return type I see no reason that the same interface can't be implemented by all. Other interfaces can also be implemented (and interfaces may extend other interfaces).

If each class uses the same interface differently then it is highly advisable to create a new interface as needed. Otherwise your code would be very confusing to future maintainers. It could also inadvertently lead to problems if used as described below (which is typical for shared interfaces).

But imagine a list of five different classes that require a getTotal() method. Declare an interface named Results and have those classes implement it. Then every instance could be placed in a List<Results> which could then iterated with each reference invoking the getTotal() method.

Collectives™ on Stack Overflow

Problem with multiple classes implements same interface

2 Answers 2

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related