Calling methods from objects which implement an interface

Question

I am trying to wrap my head around interfaces, and I was hoping they were the answer to my question.

I have made plugins and mods for different games, and sometimes classes have onUpdate or onTick or other methods that are overridable.

If I make an interface with a method, and I make other classes which implement the method, and I make instances of the classes, then how can I call that method from all the objects at once?

Answer 1

The crux would be to have a list that stores every time a class that implements the interface is instantiated. This list would have to be available at a level different that the interface and the class that implements it. In other words, the class that orchestrates or controls would have the list.

An interface is a contract that leaves the implementation to the classes that implements the interface. Classes implement the interface abide by that contract and implement the methods and not override them.

Taking the interface to be

 public interface Model {
        public void onUpdate();
        public void onClick();
       }       

    public class plugin implements Model {

        @Override
        public void onUpdate() {
            System.out.println("Pluging updating");

        }

        @Override
        public void onClick() {
            System.out.println("Pluging doing click action");

        }
    }

Your controller class would be the one to instantiate and control the action

 public class Controller {

    public static void orchestrate(){
        List<Model> modelList = new ArrayList<Model>();
        Model pluginOne  = new plugin(); 
        Model plugTwo  = new plugin();
        modelList.add(pluginOne);
        modelList.add(plugTwo);

        for(Model model:modelList){
            model.onUpdate();
            model.onClick();
        }
    }
}

You can have another implementation called pluginTwo, instantiate it, add it to the list and call the methods specified by the interface on it.

Answer 2

You'll be looking at the Observer pattern or something similar. The gist of it is this: somewhere you have to keep a list (ArrayList suffices) of type "your interface". Each time a new object is created, add it to this list. Afterwards you can perform a loop on the list and call the method on every object in it.

I'll edit in a moment with a code example.

public interface IMyInterface {
    void DoSomething();
}

public class MyClass : IMyInterface {
    public void DoSomething() {
         Console.WriteLine("I'm inside MyClass");
    }
}

public class AnotherClass : IMyInterface {
    public void DoSomething() {
         Console.WriteLine("I'm inside AnotherClass");
    }
}


public class StartUp {
    private ICollection<IMyInterface> _interfaces = new Collection<IMyInterface>();

    private static void Main(string[] args) {
        new StartUp();
    }

    public StartUp() {
        AddToWatchlist(new AnotherClass());
        AddToWatchlist(new MyClass());
        AddToWatchlist(new MyClass());
        AddToWatchlist(new AnotherClass());
        Notify();
        Console.ReadKey();
    }

    private void AddToWatchlist(IMyInterface obj) {
        _interfaces.Add(obj);
    }

    private void Notify() {
        foreach (var myInterface in _interfaces) {
            myInterface.DoSomething();
        }
    }
}

Output:

I'm inside AnotherClass 
I'm inside MyClass 
I'm inside MyClass 
I'm inside AnotherClass

Edit: I just realized you tagged it as Java. This is written in C#, but there is no real difference other than the use of ArrayList instead of Collection.

Answer 3

An interface defines a service contract. In simple terms, it defines what can you do with a class.

For example, let's use a simple interface called ICount. It defines a count method, so every class implementing it will have to provide an implementation.

public interface ICount {
    public int count();
}

Any class implementing ICount, should override the method and give it a behaviour:

public class Counter1 implements ICount {
    //Fields, Getters, Setters
    @Overide
    public int count() {
        //I don't wanna count, so I return 4.
        return 4;
    }
}

On the other hand, Counter2 has a different oppinion of what should count do:

public class Counter2 implements ICount {
    int counter; //Default initialization to 0
    //Fields, Getters, Setters
    @Overide
    public int count() {
        return ++count;
    }
}

Now, you have two classes implementing the same interface, so, how do you treat them equally? Simple, by using the first common class/interface they share: ICount.

ICount count1 = new Counter1();
ICount count2 = new Counter2();
List<ICount> counterList = new ArrayList<ICount>();
counterList.add(count1);
counterList.add(count2);

Or, if you want to save some lines of code:

List<ICount> counterList = new ArrayList<ICount>();
counterList.add(new Counter1());
counterList.add(new Counter2());

Now, counterList contains two objects of different type but with the same interface in common(ICounter) in a list containing objects that implement that interface. You can iterave over them and invoke the method count. Counter1 will return 0 while Counter2 will return a result based on how many times did you invoke count:

for(ICount current : counterList)
    System.out.println(current.count());

Answer 4

Interfaces don't work that way. They act like some kind of mask that several classes can use. For instance:

public interface Data {
    public void doSomething();
}

public class SomeDataStructure implements Data {
    public void doSomething()
    {
        // do something
    }
}

public static void main(String[] args) {
    Data mydataobject = new SomeDataStructure();
}

This uses the Data 'mask' that several classes can use and have certain functionality, but you can use different classes to actually implement that very functionality.

Answer 5

You can't call a method from all the objects that happen to implement a certain interface at once. You wouldn't want that anyways. You can, however, use polymorphism to refer to all these objects by the interface name. For example, with

interface A { }
class B implements A { }
class C implements A { }

You can write

A b = new B();
A c = new C();