Question

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

Cat cat; 
Dog dog;
Horse horse;

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

Answer 1

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

Answer 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
}

Answer 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()会更好，该方法被Horse覆盖为对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代替类。

Answer 4

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

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的行为将发生变化。

Answer 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);

    }
}

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

5 个答案: