ArrayList contenente diversi oggetti dello stesso superclasse - come accedere metodo di una sottoclasse

Question

Ciao mi chiedo se c'è una semplice soluzione al mio problema,

Ho un 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()); 

Tutti implementano un metodo move() - Il Bird vola quando viene chiamato move(). So che posso accedere a metodi e le proprietà della classe Super comuni utilizzando questo

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

va bene - ma ora vorrei accedere al metodo move() la sottoclasse Bird ha. ho potuto farlo lanciando il Animal come Bird:

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

Nella mia situazione non voglio fare questo, perché vorrà dire che ho 3 diversi set di codice uno sopra per ogni sottotipo di Animal.

Sembra un po 'ridondante, c'è un modo migliore?

Answer 1

Non c'è davvero un buon modo per farlo dalla superclasse, poiché il comportamento di ciascuna sottoclasse sarà diverso.

Per assicurarsi che si stia effettivamente chiamando il metodo appropriato move, modificare Animal da una superclasse a un'interfaccia. Quindi, quando chiami il metodo move, sarai in grado di assicurarti di chiamare il metodo di spostamento appropriato per l'oggetto che desideri.

Se si desidera conservare i campi comuni, è possibile definire una classe astratta AnimalBase e richiedere a tutti gli animali di creare tale valore, ma ciascuna implementazione dovrà implementare l'interfaccia Animal.

Esempio:

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

Nel tuo caso, quanto segue potrebbe funzionare, ma il tempo è la complessità O (n):

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

Answer 3

Non avete bisogno di fare qualsiasi casting. Il metodo override dovrebbe avere chiamato [semplice polimorfismo]

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

Sopra codice deve chiamare il metodo uccello se l'oggetto è di uccello, non è vero?

E il casting non è una soluzione, come deciderete quale oggetto trasmettere? Dovrai usare instanceOf.

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