How to call a method that has an interface as a parameter?

Question

I have the following method in a class:

public void Process(Measurable x)
{
    String y = x.getResult();

    for (int k = 0; k<item.length; k++)
    {
        if (y.equals(item[k])) tally[k]++;
    }
}

My question is, how do I call the Process method? Calling it with

Process(Measurable y);

in the default constructor or the driver class doesn't work, nor does calling it with no parameter (as I would expect).

Provide an implementation instance of the `Measurable` interface. You can even use an [anonymous class](http://docstore.mik.ua/orelly/java-ent/jnut/ch03_12.htm) to handle the job. — Luiggi Mendoza, Mar 14 '13 at 16:27
What driver class are you talking about? does this method belong to the class `Process`? — asgs, Mar 14 '13 at 16:27
Well what argument do you *want* to use? Do you understand that you're trying to supply information to the method? Where do you expect that information to come from? — Jon Skeet, Mar 14 '13 at 16:30

score 2 · Answer 1 · answered Mar 14 '13 at 16:31

// How to call your Process method
Measureable y = new ConcreteMeasureable()
Process(y);

// Assuming you have something like this... 
class ConcreteMeasureable implements Measureable
{
    @Override
    public String getResult()
    {
        return "something here";
    }
}

score 1 · Answer 2 · answered Mar 14 '13 at 16:30

1

Call the Process method with an instance of a class that implements the Measurable interface; even an anonymous class would do.

answered Mar 14 '13 at 16:30

rgettman

176,041
30
275
357

Thank you! I'm sure that's very basic. – user2170672 Mar 14 '13 at 16:41

score 1 · Accepted Answer · edited May 23 '17 at 11:57

1

You would call it with a class implementing the Measurable interface. For example:

Assume you have the class:

class Foo implements Measurable {
    @Overrride
    public String getResult(){ return "bar"; }
}

And then you could call Process like so:

Process(new Foo());

This takes advantage of an Object Oriented Programming idea called Polymorphism.

People have also mentioned that you can use anonymous inner class like so:

Process(new Measurable(){
    @Override
    public String getResult() {
        return "hey!";
    }
});

edited May 23 '17 at 11:57

Community

1
1

answered Mar 14 '13 at 16:30

jjnguy

136,852
53
295
323

Thank you! I should have known that. – user2170672 Mar 14 '13 at 16:41

score 1 · Answer 4 · answered Mar 14 '13 at 16:32

You need to create an object that implements Measurable:

public class Test {
  public static void main(String args[]) {
    new Test().test();
  }

  public interface Measurable {
    String getResult();
  }

  // Here to make `Process` compile.
  String[] item;
  int[] tally;

  public void Process(Measurable x) {
    String y = x.getResult();

    for (int k = 0; k < item.length; k++) {
      if (y.equals(item[k])) {
        tally[k]++;
      }
    }
  }

  static class M implements Measurable {

    @Override
    public String getResult() {
      return "M";
    }

  }

  public void test() {
    // Create an Object on the fly that implements Measurable (in a rather silly way).
    Process(new Measurable() {

      @Override
      public String getResult() {
        return "Hello";
      }

    });
    // Do it a bit more normally.
    Process(new M());
  }
}

asteri · Answer 5 · 2013-03-14T16:37:05.843

You can treat objects that implement the interface as the interface type using polymorphism, even though you can't directly instantiate an object of it.

For example, if Measurable is an interface, and we have a class like this:

public class MeasuredObject implements Measurable {
    ...
}

Then we can do something like the following:

MeasuredObject object = new MeasuredObject();
Measurable measurableObject = (Measurable) object;

This should show that calling your method is possible.

Process(measurableObject);

While the explicit type casting isn't necessary, it should help illustrate the concept.

(Small side note: consider adhering to Java coding standards and making your method names into camelCase. It makes your code much more readable.)

score 0 · Answer 6 · answered Mar 14 '13 at 16:33

Try something like:

public class Driver {
    public static void main(String...args) {
        Driver driver = new Driver();
        Foo foo = new Foo();
        driver.process(foo);
    }

    public void process(Measurable x) {
        String y = x.getResult();

        for (int k = 0; k<item.length; k++) {
            if (y.equals(item[k])) tally[k]++;
        }
    }

    private class Foo implements Measurable {
        String getResult() {
            /* Do stuff */
        }
    }

    public interface Measurable {
        String getResult();
    }
}

There's also a y, item, and tally in there somewhere.

P.S. In Java method names are generally lower camel cased.

How to call a method that has an interface as a parameter?

6 Answers6