ArrayList Java ¿Como puedo saber cuando recibo parametro objeto el tipo?

[Shakar]

Hola. Tengo la clase padre Persona, y tengo las clases hija Jugador y Entrenador, ¿Como puedo saber si cuando recibo por parametro un objeto es de tipo Jugador o Entrenador? Cada clase de Jugador y Entrenador tiene un metodo que devuelve su informacion personal.

Código: [Seleccionar]

public void consultar(Persona persona){
   
    if(listaPersona.contains(persona)){
       
         if(persona instanceof Jugador){
         //persona.printJugador();
         }
         if(persona instanceof Entrenador){
         //persona.printEntrenador();
         }
         else{
         persona.printPersona();
         }
    }
   
    else{
        System.out.println("Persona no existe");
    }
   
   
   
}

El compilador me devuelve como que el metodo printJugador de la clase Jugador no existe, al igual que de la clase Entrenador... Si comento la linea, el compilador me dice que esta todo OK.
¿Que puedo hacer?

[ESOJ]

Buenos días.
Tendría que ver la clase Jugador para ver donde está el posible error en el método  printJugador().

En cuanto a como saber de que tipo es el objeto que recibes por parámetro,dependera de como hayas declarado el objeto.

Un saludo

[camoay]

Hola Shakar, para que te podamos ayudar es importante que pongas la mayor información posible. Eso te lo indica las instrucciones para participar o publicar en el Foro.

 De entrada te recomiendo que describas en el mensaje del tema de tu consulta alguna referencia al curso, lección y conceptos a los que pertenece la consulta.

También tendrás que publicar todas las clases implicadas, para poder detectar el origen del error.

Saludos,

[Shakar]

Bueno la clase Persona es la siguiente:

Código: [Seleccionar]

public class Persona
{
    // instance variables - replace the example below with your own
    private String nombres;
    private String apellidos;
    private String rut;
    private Pais pais;

    /**
     * Constructor sin parametros para la Clase Persona
     */
    public Persona(){
       setNombres("Sin Nombres");
       setApellidos("Sin apellidos");
       setRut("1-9");
       setPais(new Pais());
    }

    /**
     * Constructor con parametros para la Clase Persona
     * @param String nombres
     * @param String apellidos
     */
    public Persona(String nombres, String apellidos,String rut, Pais pais){
       setNombres(nombres);
       setApellidos(apellidos);
       setRut(rut);
       setPais(pais);
    }
   
   
    /**
     * Accesador para el atributo nombres
     * @return String nombres
     */
    public String getNombres(){
        return nombres;
    }

    /**
     * Accesador para el atributo apellidos
     * @return String apellidos
     */
    public String getApellidos(){
        return apellidos;
    }
   
    /**
     * Accesador para el atributo pais
     * @return String pais
     */
    public Pais getPais(){
        return pais;
    }
   
    /**
     * Mutador para el atributo nombres
     * @param String nombres
    */
    public void setNombres(String nombres){
        StringTokenizer tokens = new StringTokenizer(nombres.trim());
        if(tokens.countTokens()>=2){
          this.nombres=nombres.trim();
        }
        else {
            this.nombres = "Sin Nombre";
        }       
    }
       
    /**
     * Mutador para el atributo apellidos
     * @param String apellidos
    */
    public void setApellidos(String apellidos){
        if(apellidos.trim().length()>=3){
            this.apellidos = apellidos;
        }
        else{
            this.apellidos = "Sin Apellidos";
        }   
    }
   
    /**
     * Accesador para atributo rut
     * @return String
     */
    public String getRut(){
        return rut;
    }
   
    /**
     * Accesador para atributo rut
     * @return String
     */
    public void setRut(String rut){
        if(rut.trim().length()>=3){
            this.rut=rut.trim();
        }
        else{
            this.rut="NNN";
        }
    }
   
   
    /**
     * Mutador para el atributo pais
     * @param Pais pais
    */
    public void setPais(Pais newPais){
        this.pais = newPais;
    }   
   
   
    /**
     * Metodo de impresión de la clase Persona
     */
    public void printPersona()
    {
        System.out.println(toString());
    }
   
    /**
     * Metodo toString() que sobreescribe la Clase Persona
     * @return String
     */
    @Override
    public String toString()
    {
        return "Nombres: " + getNombres()
              +"Apellidos: "+ getApellidos()
              + "Rut : " + getRut()
              +"Pais: "+ pais.toString();
    }
}
La clase Jugador es la siguiente:

Código: [Seleccionar]

public class Jugador extends Persona
{
    // instance variables - replace the example below with your own
    private String posicion;
    private int numeroCamiseta;

    /**
     * Constructor sin parametros para la Clase Jugador
     */
    public Jugador(){
       super();
       this.posicion = "arquero"; // setPosicion("suplente"); //
       this.numeroCamiseta = 1; //setNumCam(13);
    }

    /**
     * Constructor con parametros para la Clase Jugador
     * @param String nombres
     * @param String apellidos
     * @param Pais pais
     * @param String posicion
     */
    public Jugador(String nombres, String apellidos,String rut,Pais pais, String posicion){
       super(nombres,apellidos,rut, pais);
       setPosicion(posicion); // this.posicion= posicion;
       setNumeroCamiseta(numeroCamiseta);
    }
   
   
    /**
     * Accesador para el atributo posicion
     * @return String posicion
     */
    public String getPosicion(){
        return posicion;
    }

    /**
     * Accesador para el atributo numeroCamiseta
     * @return int numeroCamiseta
     */
    public int getNumeroCamiseta(){
        return numeroCamiseta;
    }
   
     
    /**
     * Mutador para el atributo posicion
     * @param String posicion
    */
    public void setPosicion(String posicion){
       if(posicion.trim().equalsIgnoreCase("arquero") || posicion.trim().equalsIgnoreCase("defensa") ||
          posicion.trim().equalsIgnoreCase("volante") || posicion.trim().equalsIgnoreCase("delantero")){
           this.posicion = posicion.trim().toLowerCase();
       }
       else{
           this.posicion = "suplente";
       }
       if(getPosicion().equalsIgnoreCase("arquero")){
           this.numeroCamiseta = 1;
       }
       else if(getPosicion().equalsIgnoreCase("defensa")){
           this.numeroCamiseta = 3;
       }
       else if(getPosicion().equalsIgnoreCase("volante")){
           this.numeroCamiseta = 10;
       }
       else if(getPosicion().equalsIgnoreCase("delantero")){
           this.numeroCamiseta = 9;
       }
       else{
            this.numeroCamiseta = 13;
       }
    }

   
    /**
     * Mutador para el atributo numeroCamiseta
     * @param int numeroCamiseta
    */
    private void setNumeroCamiseta(int numeroCamiseta){
       if(getPosicion().equalsIgnoreCase("arquero")){
           this.numeroCamiseta = 1;
       }
       else if(getPosicion().equalsIgnoreCase("defensa")){
           this.numeroCamiseta = 3;
       }
       else if(getPosicion().equalsIgnoreCase("volante")){
           this.numeroCamiseta = 10;
       }
       else if(getPosicion().equalsIgnoreCase("delantero")){
           this.numeroCamiseta = 9;
       }
       else{
            this.numeroCamiseta = 13;
       }
    }
   
   
    /**
     * Metodo de impresión de la clase Jugador
     */
    public void printJugador()
    {
        System.out.println(toString());
    }
   
    /**
     * Metodo toString() que sobreescribe la Clase Jugador
     * @return String
     */
    @Override
    public String toString()
    {
        return super.toString()
            +  "Posicion:  " + getPosicion()
            +  "Numero de Camiseta   " + getNumeroCamiseta();
    }
}

y La clase entrenador es la siguiente

Código: [Seleccionar]

public class Entrenador extends Persona
{
    // instance variables - replace the example below with your own
    private int anioExperiencia;

    /**
     * Constructor sin parametros para la Clase Entrenador
     */
    public Entrenador(){
       super();
       setAnioExperiencia(1);
    }

    /**
     * Constructor con parametros para la Clase Entrenador
     * @param String nombres
     * @param String apellidos
     * @param Pais pais
     * @param int anioExperiencia
     */
    public Entrenador(String nombres, String apellidos,String rut, Pais pais, int anioExperiencia){
       super(nombres,apellidos,rut,pais);
       setAnioExperiencia(anioExperiencia);
    }
   
   
    /**
     * Accesador para el atributo anioExperiencia
     * @return int anioExperiencia
     */
    public int getAnioExperiencia(){
        return anioExperiencia;
    }
   
   
    /**
     * Mutador para el atributo anioExperiencia
     * @param int anioExperiencia
    */
    public void setAnioExperiencia(int anioExperiencia){
        if(anioExperiencia>0){
            this.anioExperiencia = anioExperiencia;
        }
        else {
            this.anioExperiencia = 1;
        }       
    }
   
   
    /**
     * Metodo de impresión de la clase Entrenador
     */
    public void printEntrenador()
    {
        System.out.println(toString());
    }
   
    /**
     * Metodo toString() que sobreescribe la Clase Entrenador
     * @return String
     */
    @Override
    public String toString()
    {
        return super.toString()
            +  "Años de experiencia;  " + getAnioExperiencia();
    }
}

Ambas tienen opcion de imprimir su informacion, y es al metodo que intento llegar... creo que el problema va por no poder hacer "refundicion" a cualquier cosa. No es algun ejercicio o que haga referencia el curso, es algo propio.

Bueno el tema es que al final lo solucione de esta forma, y no sé si sera la correcta, y tampoco sé porque compilo de esta forma

Código: [Seleccionar]

public void consultar(Persona persona){
   
    if(listaPersona.contains(persona)){
       
         if(persona instanceof Jugador){
         Jugador jug = (Jugador)persona;
         jug.printJugador();
         }
         if(persona instanceof Entrenador){
         Entrenador ent = (Entrenador)persona;
         ent.printEntrenador();
         }
         else{
         persona.printPersona();
         }
    }
   
    else{
        System.out.println("Persona no existe");
    }
   
   
   
}
Porque no compilaba cuando directamente tomaba el objeto persona de la Clase Persona que recibia por parametro, e invoca el metodo printJugador??
El cual fue el puse en el primer comentario:

Código: [Seleccionar]

public void consultar(Persona persona){
   
    if(listaPersona.contains(persona)){
       
         if(persona instanceof Jugador){
         //persona.printJugador();
         }
         if(persona instanceof Entrenador){
         //persona.printEntrenador();
         }
         else{
         persona.printPersona();
         }
    }
   
    else{
        System.out.println("Persona no existe");
    }
   
   
   
}
Podía invocar el printPersona(), pero no los métodos para las otras clases... entonces ahí quede pillado. Si alguien con mas experiencia me explica con peritas y manzanas quedo mega feliz y agradecido. Desde ya comenzare a participar en el foro respondiendo a los que están iniciándose.
De antemano gracias

[camoay]

Buenas tardes Shakar,
Por favor, respóndeme a lo siguiente:
a) ¿ el método consultar() pertenece a otra clase donde está definida la listaPersona?
a1) Si la respuesta es si --> publica dicha clase,
a2) Si la respuesta es no--> publica dicha clase y publica la clase de listaPersona,
b) ¿Existe aparte otra clase con el método main() donde crees los objetos para probarlo todo? 
b1) Si la respuesta es si -->  publica dicha clase,

Creo que el error viene por cómo estás creando los objetos, el tipo estático y el tipo dinámico, o lo mismo en la creacion de la listaPersona

Saludos,

[Shakar]

Esta es la clase consultar

Código: [Seleccionar]

public class Persistencia
{
   
   
    ArrayList<Equipo> listaEquipo = new ArrayList<Equipo>();
    ArrayList<Persona> listaPersona = new ArrayList<Persona>();
   
    public Persistencia()
    {
        // initialise instance variables
       
    }

 


public String agregarPersonaLista(Object obj){
   
    if(obj instanceof Persona){
         
        if(listaPersona.contains(obj)){
            return "Objeto duplicado";
        }
        else{
            listaPersona.add((Persona)obj);
            return "Objeto agregado";
        }
               
     
             
    }
    else{
       
        return "Objeto no corresponde a una Persona";
    }
}

public int cantidadRegistro(){
    return listaPersona.size();
}
 

public void consultar(Persona persona){
   
    if(listaPersona.contains(persona)){
       
         if(persona instanceof Jugador){
         Jugador jug = (Jugador)persona;
         jug.printJugador();
         }
         if(persona instanceof Entrenador){
         Entrenador ent = (Entrenador)persona;
         ent.printEntrenador();
         }
         else{
         persona.printPersona();
         }
    }
   
    else{
        System.out.println("Persona no existe");
    }
   
   
   
}


}
La clase con el metodo main para hacer pruebas

Código: [Seleccionar]

public class Test
{
   
    public static void main(String args []){
        Persona per1 = new Persona();
        Equipo equip1 = new Equipo();
        Persistencia per = new Persistencia();
        per.agregarPersonaLista(per1);
        per.cantidadRegistro();
       
    }

}

[camoay]

buenos días Shakar.
1) entiendo que tendrás creadas las clases País y Equipo.
2)¿por que usas un tipo Object como parámetro en el método agregarPersonaLista()¿
3) en el método main() solo creas 3 objetos: persona(), Equipo() y Persistencia(), por lo que sólo existen esos objetos y sin parámetros. Por ello, solo se podrá ejecutar el método printPersona(), ya que no existe ningún jugador ni entrenador para poder eje cutar los métodos printJugador() o printEntrenador().
Espero haberte ayudado, saludos

[Shakar]

1) si están creadas las clases pais
2) uso tipo Object como parametro porque asi lo exige el profesor de la Universidad. Yo igual quede como "Plop" cuando vi eso. Es que el ejercicio no es mio, es de un amigo. Aunque recibiendolo se puede refundir o castear a la clase que pertenece.
3) Si, creo los 3 objetos con constructor por defecto, pero el problema, es el que puse en el el primer post.

Tengo la clase padre Persona, y tengo las clases hija Jugador y Entrenador, ¿Como puedo saber si cuando recibo por parametro un objeto es de tipo Jugador o Entrenador? Cada clase de Jugador y Entrenador tiene un metodo que devuelve su informacion personal.

Código: [Seleccionar]

public void consultar(Persona persona){
   
    if(listaPersona.contains(persona)){
       
         if(persona instanceof Jugador){
         //persona.printJugador();
         }
         if(persona instanceof Entrenador){
         //persona.printEntrenador();
         }
         else{
         persona.printPersona();
         }
    }
   
    else{
Si compilo eso me da error....

--------------------------------------------------------------------------------
Pero si lo cambio a esta forma compila, ¿Porque? Esa es la respuesta que estoy buscando... no me tengo explicación.

Código: [Seleccionar]

public void consultar(Persona persona){
   
    if(listaPersona.contains(persona)){
       
         if(persona instanceof Jugador){
         Jugador jug = (Jugador)persona;
         jug.printJugador();
         }
         if(persona instanceof Entrenador){
         Entrenador ent = (Entrenador)persona;
         ent.printEntrenador();
         }
         else{
         persona.printPersona();
         }
    }
   
    else{
        System.out.println("Persona no existe");
    }
   
   
   
}
Porque compila asi? Y no compila de la otra forma? en el metodo consultar(), de la clase Persistencia?

[camoay]

Buenas noches Shakar, te comento...
No es lo mismo comparar :
a) si una superclase es un instancia de una subclase, que ,
b) si una subclase es instancia de una superclase,
En el caso b) es evidente y el compilador dice true y no hace falta nada mas...
En el caso a) la superclase realmente no es una instancia de la subclase, pero el compilador sabe que están en la misma linea jerárquica y lo acepta bajo ciertas condiciones, como es el hacer casting a la variable declarada como tipo superclase para con ello decirle que realmente es, o apunta a un objeto de la subclase. Con ello la comparación ya es válida para el compilador y deja continuar...
Espero haberme expresado  con claridad y que te haya ayudado.