如何将更多类型的参数传递给一个参数的方法答案

【问题标题】：how to pass more types arguments into method with one parameter如何将更多类型的参数传递给一个参数的方法
【发布时间】：2018-08-01 16:22:13
【问题描述】：

我有几个具有不同对象类型猫、狗和马的类。我有一个根类，其中方法 doSomethig 只有一个我想在其余类中调用的参数。如何编写没有类型冲突的方法。这只是一个例子。

Cat cat; 
Dog dog;
Horse horse;

protected void doSomething(one parameter){
  cat.doMeow();
  dog.doBark();
  horse.run();
}

【问题讨论】：

什么类型冲突？
如果我在根类设置参数中，我会从其余类中调用此方法，例如doSomething(Dog xyz) 我可以从 Cat 或 Horse 类中将 Cat 或 horse 发送到此方法。
您有Cat、Dog 和Horse 的基类吗？ Animal 之类的东西？
@alexander.egger 我认为这对 OP 没有帮助，因为 doSomething() 想根据类型调用不同的方法。在我看来，这听起来像是为每种类型创建重载是最简单的解决方案。
问题不清楚 - 添加更多代码以提供上下文。

标签： java oop parameters interface polymorphism

【解决方案1】：

为什么不扩展父类 Animal 会有 doSomething（一个参数），然后在子类中调用 super() ？

【讨论】：

【解决方案2】：

如果我没听错的话，签名只针对一个参数是固定的。但是您需要访问cat、dog 和horse？在这种情况下，您需要将one 调整为parameter object。

（此外，它应该以大写字母开头，作为普遍接受的代码样式）

public class one
{
    private Cat cat;
    private Dog dog;
    private Horse horse;

    public one(Cat cat, Dog dog, Horse horse)
    {
        this.cat = cat;
        this.dog = dog;
        this.horse = horse;
    }

    public Cat getCat()
    {
        return this.cat
    }

    // getDog(), getHorse()
}

然后在doSomething方法中使用getter方法

protected void doSomething(one parameter){
    parameter.getCat().doMeow();
    parameter.getDog().doBark();
    parameter.getHorse().run();
}

这样称呼它：

public void myMethod()
{
    one animals = new one(new Cat(), new Dog(), new Horse());
    doSomething(animals); // if same class or myInstance.doSomething(animals) if another class
}

【讨论】：

【解决方案3】：

蛮力解决方案是传递一个对象，例如Animal 类型的并在方法中检查类型，并根据类型检查的结果调用相应的方法：

protected void doSOmething(Animal an Animal) {
  if( anAnimal instanceof Horse)
    ((Horse) anAnimal).run();
  else if( anAnimal instanceof Dog )
    ((Dog) anAnimal).bark();
  else ...
}

但是，这被认为是不好的风格，因为该方法对马、狗等有太多的了解。如果Animal 有一个抽象方法doDefaultAction() 会更好，它被马覆盖为对run() 的调用，被狗覆盖为对bark() 的调用，等等。

abstract class Animal {
  abstract void doDefaultAction(Animal anAnimal);
}

class Horse extends Animal {
  @Override
  void doDefaultAction(Animal anAnimal) {
    ((Horse) anAnimal).run();
  }

  void run() { /* do some running */ }
}

在您的方法doSomething() 中，您只需调用anAnimal.doDefaultAction() 而无需知道动物的默认操作可能是什么。如果抽象 Animal 类没有做其他事情，您也可以考虑使用 interface Animal 代替类。

【讨论】：

【解决方案4】：

您可以创建一个通用接口并调用接口方法。例如：

public interface Animal {
    public void act();
}

public class Cat implements Animal {

    public void doMeow() { /* ... */ }

    @Override
    public void act() {
        doMeow();
    }
}

public class Dog implements Animal {

    public void doBark() { /* ... */ }

    @Override
    public void act() {
        doBark();
    }

}

那么doSomething方法可以多态调用act方法：

protected void doSomething(Animal animal) {
    animal.act();
}

根据传递的对象（例如Cat 或Dog），doSomething 的行为会发生变化。

【讨论】：

【解决方案5】：

假设这是经典的 OO 继承示例。一个简单的解决方案是这样的：

public class AnimalExample {

    interface Animal {
        void action();
    }

    public static class Cat implements Animal{

        @Override
        public void action() {
            System.out.println("meow");
        }
    }

    public static class Dog implements Animal{

        @Override
        public void action() {
            System.out.println("bark");
        }
    }

    public static class Horse implements Animal{

        @Override
        public void action() {
            System.out.println("run");
        }
    }

    static void doSomething(Animal animal){
        animal.action();
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        Horse horse = new Horse();

        doSomething(cat);
        doSomething(dog);
        doSomething(horse);

    }
}

【讨论】：