Question

不确定这是否称为“方法隐藏”或“方法覆盖”，或者两者都没有，并且希望被引导到关于该主题的一些好文章。特别是，它是否是良好的做法，何时何地不使用它，以及使用它的优点/缺点。

public class Animal {

  /* constructor */
  Animal () { }

  /* instance method */
  void add(Number n) {
    System.out.println("An animal added a number!");
  }

  /* Main method */
  public static void main(String[] args) {
    Integer i = 2;   // Integer i = new Integer(2);
    Double d = 3.14; // Double d = new Double(3.14);

    Animal mammal = new Animal();
    Cat tom = new Cat();
    Mouse jerry = new Mouse();

    mammal.add(i); // produces "An animal added a number!"
    mammal.add(d); // produces "An animal added a number!"

    tom.add(i);    // produces "Tom added an integer!"
    tom.add(d);    // produces "An animal added a number!"

    jerry.add(i);  // produces "An animal added a number!"
    jerry.add(d);  // produces "Jerry added a double!"
  }
}

class Cat extends Animal {

  /* constructor */
  Cat () { }

  /* instance method */
  void add(Integer i) {
    // param of type Integer extends Number
    System.out.println("Tom added an integer!");
  }
}

class Mouse extends Animal {

  /* constructor */
  Mouse () { }

  /* instance method */
  void add(Double d) {
    // param of type Double extends Number
    System.out.println("Jerry added a double!");
  }
}

编辑：

感谢@MByD，发现这被称为“方法重载”。

与上述相关的新问题：在Animal类中，我想创建一个方法，该方法接受Number对象并使用子类add()和Cat中的一个重载Mouse方法。有没有比下面显示的更好的方法呢？

public class Animal {
...
  void subtract(Number n) {
    if      (n instanceof Integer) this.add(-(Integer) n); // from the Cat class
    else if (n instanceof Double)  this.add(-(Double) n);  // from the Mouse class
    ...
  }
...
}

是的，我意识到我可以写this.add(-n)，但我想知道是否有办法选择依赖于参数子类的实现。由于参数是抽象类型且无法实例化，因此我必须传递子类作为参数。

Answer 1

这称为方法重载，因为方法的签名不一样。

请参阅Java Tutorials of methods：

Java编程语言支持重载方法和Java 可以区分具有不同方法签名的方法。这个表示类中的方法具有相同的名称不同的参数列表（有一些资格证明将在标题为“接口和继承”的课程中讨论。

是否以及何时使用各种重载/覆盖/阴影等的论点是一个很大的问题。 Joshua Bloch撰写了一本非常好的资源Effective Java。我发现这非常有用和有趣。

使用子类参数隐藏方法

1 个答案: