Array de com dados de vários tipos de dados (polimorfismo)

[boavida]

Boas,

tenho uma classe pai e uma filho

depois tenho um array com o tipo pai.

e sei que tenho dentro do array os dados do filho

só que estou numa classe principal , e no metodo main, não estou a conseguir fazer o output  dos dados do filho através do array

Agradeço desde já a quem tiver oportunidade para dar uma dica!

[brunoais]

Sem código é demasiado confuso

[HappyHippyHippo]

for (i = 0; ...; ...) {
  if (lista[i].getClass().getSimpleName().equals("Pai")) {
    Pai aux = (Pai)lista[i];
    ...
  } else {
    Filho aux = (Filho)lista[i];
    ...
  }
}

[Knitter]

Esse exemplo derrota um pouco a ideia de polimorfismo. Se a classe pai tiver o método de apresentação de dados, então a classe filho só terá de o re-implementar.

[brunoais]

...

É melhor assim:

for (i = 0; ...; ...) {
  if (lista[i].getClass() == Pai.class) {
    Pai aux = (Pai)lista[i];
    ...
  } else {
    Filho aux = (Filho)lista[i];
    ...
  }
}

[HappyHippyHippo]

É melhor assim:

como já referi aqui no forum, sei java mas não é o meu forte ... até porque não programo nada em java já vai prai 5 anos ...

mas obrigada, também gosto de aprender

[Knitter]

Qualquer um dos dois exemplos é um mau exemplo se o objectivo é usar polimorfismo. Se o objectivo não é usar polimorfismo continuaria a ser um mau exemplo mas, eventualmente, passível de ser usado.

Recorrendo a polimorfismo a única forma de obter o que foi pedido é se a classe filho implementar o mesmo método que é chamado na classe pai. Ex:

public class Pai {

    private String nome;

    public Pai(String nome) {
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }

    public void apresentar() {
        System.out.println("Olá, o meu nome é " + nome);
    }
}

class Filho extends Pai {

    private Pai pai;

    public Filho(String nome, Pai pai) {
        super(nome);

        this.pai = pai;
    }

    @Override
    public void apresentar() {
        super.apresentar();
        System.out.println("E sou filho de " + pai.getNome());
    }
}

O método será escolhido de acordo com o tipo de dados real contido no vector:

public static void main(String[] args) {
    Pai[] pessoas = new Pai[5];

    pessoas[0] = new Pai("João");
    pessoas[1] = new Pai("António");
    pessoas[2] = new Filho("João Jr.", pessoas[0]);
    pessoas[3] = new Filho("Ricardo", pessoas[0]);
    pessoas[4] = new Filho("Miguel", pessoas[1]);

    for (int i = 0; i < pessoas.length; i++) {
        pessoas[i].apresentar();
    }
}

[HappyHippyHippo]

isso claro é no mundo ideal ....

imagina isto :

class Objecto {
  protected float area;

  public float function getArea() {
    return this->area;
  }
}

class Objecto3D extends Objecto {
  protected float volume;

  public float function getVolume() {
    return this->volume;
  }
}

int main(String[] args) {
  Objecto lista[];

  // calcular o volume dos objectos guardados na lista ...
}

e não venhas dizer que para isso tens de ter duas listas diferentes ....

[Knitter]

Por isso é que reforcei o facto de estar a usar polimorfismo, em que o comportamento de um objecto é alterado ao longo da hierarquia. No caso que indicaste foge ao polimorfismo já que não queres alterar/refinar/etc o comportamento herdado mas sim acrescentar comportamentos novos.

E sim, a solução mais simples seria a utilização de estruturas diferentes já que não faz sentido ter os objectos misturados, não ganhas nada com isso, mas mesmo que estivesses na mesma lista, usar o nome da classe não seria a primeira opção, há opções mais simples.

[pedrotuga]

Acho que o que o boavida quer é um caso típico de polimorfismo

class A{
int attA;
void metodo(){
System.out.println(attA);
}
}

class B extends A{
/*podes fazer override do método (a anotação '@override' é opcional)*/
@override
void metodo(){
System.out.println("cebolas");
}
}


A a = new A();
A b = (A) new B();

A[] aArray;
anArray = new A[2];

a.attA = "gelados";

//podes meter ambos os objectos dentro do mesmo array mas têm que ser do mesmo tipo, independentemente do construtor que usares
aArray[0] = a;
aArray[1] = b;

aArray[0].metodo(); //gelados
aArray[1].metodo(); //cebolas

Ter em atenção que casts impossibilitam o compilador de detectar erros de incompatibilidade de tipos. Caso não seja possível converter um tipo de dados noutro, o erro acaba por ocorrer em runtime.

Uma solução mais robusta é usar interfaces ou genéricos, mas isso já é off-topic