ArrayList包含同一个超类的不同对象 - 如何访问子类的方法

Question

Hi I'm wondering if there is a simple solution to my problem,

I have an ArrayList :

ArrayList <Animal> animalList = new ArrayList<Animal>(); 

/* I add some objects from subclasses of Animal */

animalList.add(new Reptile());
animalList.add(new Bird());
animalList.add(new Amphibian());

They all implement a method move() - The Bird flies when move() is called. I know I can access common methods and properties of the super class by using this

public void feed(Integer animalIndex) {
    Animal aAnimal = (Animal) this.animalList.get(animalIndex);
    aAnimal.eat();
}

That's fine - but now I would like to access the move() method the subclass Bird has. I could do this by casting the Animal as a Bird :

Bird aBird = (Bird) this.animalList.get(animalIndex);
aBird.move();

In my situation I don't want to do this, as it will mean I have 3 different sets of the above code one for each subtype of Animal .

It seems a bit redundant, is there a better way?

Answer 1

There really isn't a nice way to do this from the superclass, since the behavior of each subclass will be different.

To ensure that you're actually calling the appropriate move method, change Animal from a superclass to an interface. Then when you call the move method, you'll be able to ensure that you're calling the appropriate move method for the object you want.

If you're looking to preserve common fields, then you can define an abstract class AnimalBase , and require all animals to build off of that, but each implementation will need to implement the Animal interface.

Example:

public abstract class AnimalBase {
    private String name;
    private int age;
    private boolean gender;

    // getters and setters for the above are good to have here
}

public interface Animal {
    public void move();
    public void eat();
    public void sleep();
}

// The below won't compile because the contract for the interface changed.
// You'll have to implement eat and sleep for each object.

public class Reptiles extends AnimalBase implements Animal {
    public void move() {
        System.out.println("Slither!");
    }
}

public class Birds extends AnimalBase implements Animal {
    public void move() {
        System.out.println("Flap flap!");
    }
}

public class Amphibians extends AnimalBase implements Animal {
    public void move() {
        System.out.println("Some sort of moving sound...");
    }
}

// in some method, you'll be calling the below

List<Animal> animalList = new ArrayList<>();

animalList.add(new Reptiles());
animalList.add(new Amphibians());
animalList.add(new Birds());

// call your method without fear of it being generic

for(Animal a : animalList) {
    a.move();
}

Answer 2

You dont need to do any casting. The overridden method should get called [simple polymorphism]

Animal aAnimal==  this.animalList.get(animalIndex);
aAnimal.move();

Above code should call bird method if object is of bird, isn't it?

And casting is not a solution , how will you decide which object to cast? You will have to use instanceOf.

Answer 3

In your case,the following could work,but time complexity is O(n):

public void moveBird(){
    for(Animal aminal:animalList){
        if(animal instanceof Bird){
            aninmal.move();
        }
    }
}

Answer 4

Bird getMyBird(Integer aniInteger) {
        Bird b = new Bird();
        //Do somthig with bird object...

        return b;
        //get your modifeid bird object
    }

    Bird myBird = animalList.get(animalIndex);

    myBird.move();