3

我在一个类中有以下方法：

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

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

我的问题是，如何调用 Process 方法？调用它

Process(Measurable y);

在默认构造函数或驱动程序类中不起作用，也不会在没有参数的情况下调用它（如我所料）。

4

6 回答 6

2 
// 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";
    }
}
于 2013-03-14T16:31:39.690 回答
1

您需要创建一个实现的对象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());
  }
}
于 2013-03-14T16:32:22.793 回答
1

用实现接口Process的类的实例调用方法；Measurable即使是匿名类也可以。

于 2013-03-14T16:30:05.667 回答
1

Measurable你可以用一个实现接口的类来调用它。例如：

假设您有课程：

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

然后你可以这样调用Process：

Process(new Foo());

这利用了称为多态的面向对象编程思想。

人们还提到您可以像这样使用匿名内部类：

Process(new Measurable(){
    @Override
    public String getResult() {
        return "hey!";
    }
});
于 2013-03-14T16:30:43.673 回答
0

您可以使用polymorphism将实现接口的对象视为接口类型，即使您不能直接实例化它的对象。

例如，如果Measurable是一个接口，我们有一个这样的类：

public class MeasuredObject implements Measurable {
    ...
}

然后我们可以执行以下操作：

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

这应该表明调用您的方法是可能的。

Process(measurableObject);

虽然显式类型转换不是必需的，但它应该有助于说明这个概念。

（附带说明：考虑遵守 Java 编码标准并将您的方法名称改为camelCase. 它使您的代码更具可读性。）

于 2013-03-14T16:29:52.970 回答
0

尝试类似：

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();
    }
}

还有一个y, item, 和tally在某处。

PS 在 Java 中，方法名称通常是小写的驼峰式。

于 2013-03-14T16:33:58.240 回答