Los tipos parametrizados no son polimórficos java

[gatoher]

Tengo una duda sobre una explicación que no llego a comprender sobre las listas genéricas, a ver;

List<Object> es de tipo Collection<Object> por que tienen el mismo parámetro. Pero List<String> no es de tipo List<Object> ya que son distintos parametros aunque String es subtipo de Object.

Hasta aqui es comprensible pero a pone este ejemplo;

public class void main (String [] args)
{

List<String> ls = new ArrayList<String>(); // Lista de string

List<Object> lo = ls;  // Ahora las dos listas hacen referencia a ls

lo.add(new Employee()); // Añadimos un Employee a la lista
String s = ls.get(0); //Error

¿Por que ha dejado añadir un objeto Employee? Hay dos referencias de distinto tipo a un objeto, no lo llego a entender,¿ si en lugar de Object fuera Integer? Si hubiera hecho esto;

Object x = lo.get(0); // ¿Daría error?

[Mario R. Rancel]

Hola, tendrías que pegar el código completo que estás usando para poder compilarlo.

List<Object> admite cualquier tipo de objeto en la lista (por ejemplo String, Employee, o cualquier otro) porque en Java existe polimorfismo: una variable pertenece a varios tipos al mismo tiempo y todos los objetos heredan de Object.

Si escribes esto y lo compilas:

Código: [Seleccionar]

import java.util.List;
import java.util.ArrayList;

public class test{

    public static void main (String [] args){
        List<String> ls = new ArrayList<String>(); // Lista de string
        List<Object> lo = ls;  // Ahora las dos listas hacen referencia a ls
    }
}
Obtienes un error: "incompatible types: java.util.List<java.lang.String> cannot be converted to java.util.List<java.lang.Object>

No todas las conversiones son posibles en Java. En este caso te indica que no puedes cambiar el tipo estático de una variable declarada.

En el curso java desde cero (http://aprenderaprogramar.com/index.php?option=com_content&view=category&id=68&Itemid=188)

tienes las siguientes explicaciones.

Concepto de clase parametrizada: http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=631:clase-arraylist-del-api-java-metodos-add-size-etc-concepto-de-clase-generica-o-parametrizada-cu00665b&catid=68:curso-aprender-programacion-java-desde-cero&Itemid=188

Concepto de polimorfismo: http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=645:concepto-definicion-de-polimorfismo-en-java-ique-es-el-polimorfismo-ejemplo-practico-ejercicio-cu00678b&catid=68:curso-aprender-programacion-java-desde-cero&Itemid=188

Conversión de tipos en java: http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=658:ejemplos-conversion-de-tipos-en-java-enmascaramiento-casting-classcastexceptions-instanceof-cu00689b&catid=68:curso-aprender-programacion-java-desde-cero&Itemid=188

Pienso que con la explicación de la entrega CU00689B te quede claro cuáles son las posibilidades de conversión de tipos.

Saludos!!!

[gatoher]

Hola Mario, es un ejemplo de un libro y no hay más código. Tienes razón la verdad que se me olvido escribir "Asusamos que el listado xx es legal", esta en negrita  . Es un ejemplo para explicar por que no puedes meter en una Lista<Object> una lista<String>.
Si se pudiera hacer esto, "una de las cosas para lo que los genéricos estan es para evitar esto" podría suceder el problema de asignar  a una variable un tipo de dato que no le corresponde.

String s = ls.get(0);

Pero viendo la entrega CU00689B me ha quedado más claro. La única duda que tengo es si la variable interino1 no se hubiera asignado a profesor73;

 Profesor profesor73 = interino1; //Ahora el supertipo contiene un subtipo, en principio con pérdida de información

¿interino1 no sería profesor?¿Estoy equivovado ahí.?

[Mario R. Rancel]

Efectivamente el tipo estático es Profesor, pero el tipo dinámico puede ser otro.

Creo que leyendo CU00690B te quedará más claro: una variable puede ser de más de un tipo a la vez. En concreto hablamos de tipo estático para el tipo declarado y tipo dinámico para el tipo que recibe en tiempo de ejecución.

CU00690B: http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=660:sobreescribir-metodos-en-java-tipo-estatico-y-dinamico-ligadura-metodos-polimorficos-ejercicio-cu00690b&catid=68:curso-aprender-programacion-java-desde-cero&Itemid=188

Saludos

[gatoher]

Hola Mario, la verdad que la explicación esta bastante clara. Yo las pregunta que hay al final las he contestdo de esta manera;

A) No. Daría "ClassCastException", el compilador no sabe si la variable Vehiculo almacena un taxi o una ambulancia.

B)Si

E)El toString si esta sobre escrito

Un resumen que me he hecho yo es que un objeto "Hombre o Mujer" que herede de Persona, tiene además de las propiedades y metédos de su propia clase "Hombre o Mujer" las que hereda de Persona.
Pero un objeto Persona no puede recibir ni las propiedades ni los metédos de sus clases extendidas o "hijas", a no ser que un objeto declarado Persona he instanciado Mujer, tenga los metédos sobre escritos o hagas un "Molde".

Ejemplo;

 ((Mujer)Persona[0]).metodoMujer();

Corrigeme si estoy equivocado con esta reflexión  ;

Ahora viendo esto, digo yo que en el Stack, que es donde se guarda las variables de referencia habría una variable Persona y una Mujer apuntando a un mismo objeto. Este Objeto si se declara como Persona tiene en el Head en un principio únicamente todos los metódos y propiedades de una Persona.

Si más tarde se le pasa una referencia de Mujer, ese objeto en memoria también tiene  los métodos y propiedades de Mujer. Pero no puede acceder a ellos facilmente. Hay sobreescribir los métodos y se hace un casting, esto es lo raro entre "".

Por que si tu creas un objeto directamente Mujer o Hombre, que extienden a Persona, en memoria se crea un objeto con los métodos y propiedades tanto de Hombre y Mujer como de Persona. Lo lógico. Pero si esa variable "tipo Mujer" la metes en un objeto tipo Persona, deja de tener acceso a sus propiedades y métodos a no ser que ....

No se que sentido tiene el haberlo hecho asi.

[Mario R. Rancel]

A) No. Daría "ClassCastException", el compilador no sabe si la variable Vehiculo almacena un taxi o una ambulancia.

La respuesta no es correcta. Te respondo citando el texto del propio curso:

<<Se trataría de poner lo que está arriba abajo, por ejemplo poner un Profesor como ProfesorInterino. Esto no siempre es posible. El supertipo admite cualquier forma (es polimórfico) de los subtipos: si el supertipo almacena el subtipo al que queremos realizar la conversión, será posible usando lo que se denomina “Enmascaramiento de tipos” o “Hacer Casting” (cast significa “moldear”). Si el supertipo no almacena el subtipo al que queremos convertirlo, la operación no es posible y saltará un error.>>

Por tanto sí sería posible (ser posible, es posible).


B)Si --> Correcto



E)El toString si esta sobre escrito  -- > Correcto

Aclaración: Se ejecuta el método toString() del tipo contenido en el objeto (Taxi) aunque se declarara como tipo Vehiculo
Porque en tiempo de ejecución, el compilador verifica el tipo que contiene el objeto y ejecuta sus métodos, solo si no los encuentra en el tipo instanciado los busca el tipo estático.


Sobre tu razonamiento:

Pero un objeto Persona no puede recibir ni las propiedades ni los metédos de sus clases extendidas o "hijas", a no ser que un objeto declarado Persona he instanciado Mujer, tenga los metédos sobre escritos o hagas un "Molde".

Esto no es correcto: un objeto puede ser de dos tipos al mismo tiempo.

Por ejemplo: Persona p1 = new Mujer();

El objeto p1 es de tipo Persona y de tipo Mujer: por eso se dice que Java hace uso de polimorfismo (distintas formas o tipos para una variable). La sobreescritura de métodos es una cuestión aparte. El objeto p1 tendrá acceso a métodos de Persona si Persona es una superclase (otra opción sería que Persona fuera una interface).

Puedes declarar sin problemas y trabajar sin hacer casting List lista1 = new ArrayList(); ó Persona p1 = new Mujer();

Sólo tendrás que hacer casting en circunstancias muy concretas, como el caso de tratar de poner una instancia de Persona en un objeto de tipo estático Mujer.

A modo de resumen y como recomendaciones prácticas:

- Declara los objetos con el supertipo, por ejemplo List, e instáncialos con el subtipo que desees, por ejemplo ArrayList

- No te preocupes por hacer casting constantemente. Sólo si te saltan errores y en casos concretos


Saludos,

[gatoher]

Hola Mario, a ver yo cuando digo que un supertipo no puede acceder a los métodos o propiedades me refiero sin hacer casting o sobreescritura. Ejemplo;

//Clase persona
int dni;

//Clase Hombre
String nombre;

Persona p1 = new Persona();
p1= new Hombre();

p1.getNombre(); /// Error

String nombre = (Hombre)p1.getNombre(); //Forma que yo conozco

Si yo hago un arrayList de Personas y meto Hombres y Mujeres en ella, y quiero sacar un atributo que solo tienen los hombres "no se entienda mal, las mujeres tienen muchos más", con un iterator, tengo ue recorer el arrayList y luego con instanceof separar los hombre de las mujeres, y aun asi, sabiendo que es un hombre, tengo que hacer el casting.

[Mario R. Rancel]

Crea el código de las clases, postéalo y revisándolo veremos si se puede hacer de mejor manera de la que estás pensando. Como te digo, el casting sólo debe usarse cuando no hay mejores alternativas de diseño...

[gatoher]

Ok Mario, te pongo un ejercicio que hice en el modulo, sobre Computadoras. Hay una lista de Computadoras en la que metemos Portatiles  Sobremesa. Podemos ingresar, sacar y mostrar el contenido de ella. Para ingresar y sacar no hay problema, lo que va al asunto es cuando quiero mostrar los elementos de la lista con todos sus atributos.

Empiezo por la clase Computadoras;

Código: [Seleccionar]

public abstract class Computadoras {

    protected String numSerie;
    protected  String marca;
    protected String modelo;
    protected  String micro;
    protected int memoria;
    protected boolean dvd;
   
   
    //Constructor
    public Computadoras(String numSerie, String marca, String modelo, String micro, int memoria, boolean dvd) {
        this.numSerie = numSerie;
        this.marca = marca;
        this.modelo = modelo;
        this.micro = micro;
        this.memoria = memoria;
        this.dvd = dvd;
    }
   
   
    //metodo abstracto
    abstract String muestra();
     
   
  //get y set
    public String getNumSerie() {
        return numSerie;
    }

    public void setNumSerie(String numSerie) {
        this.numSerie = numSerie;
    }

    public String getMarca() {
        return marca;
    }

    public void setMarca(String marca) {
        this.marca = marca;
    }

    public String getModelo() {
        return modelo;
    }

    public void setModelo(String modelo) {
        this.modelo = modelo;
    }

    public String getMicro() {
        return micro;
    }

    public void setMicro(String micro) {
        this.micro = micro;
    }

    public int getMemoria() {
        return memoria;
    }

    public void setMemoria(int memoria) {
        this.memoria = memoria;
    }

    public boolean getDvd() {
        return dvd;
    }

    public void setDvd(boolean dvd) {
        this.dvd = dvd;
    }
   
     

    @Override
    public String toString() {
        return "El número de serie es " + numSerie + "\n" +
               " su marca es; " + marca + "\n" +
               " su modelo es; " + modelo + "." + "\n" +
               "Tiene el modelom de microprocesador; " + micro + "," + "\n"+
               " y, " + dvd + " tiene lector dvd.";
               
    }


Ahora te pongo si quieres la clase donde hice la lista. La lista esta en una clase distinta;

Código: [Seleccionar]

public class ListasComputadoras {

    private ArrayList<Computadoras> computadoras;
    private int activo = -1;
   
    //constructor
    public ListasComputadoras(){
      this.computadoras =  new ArrayList();
     
    }
    //metodo limpiar lista
    public void limpiar(){   
        // asiganmos null
        this.setComputadoras(null);
      }
     
    //Metodo insertar
    public void insertar(Computadoras obj){   
        this.getComputadoras().add(obj);
     
     
    }
   
    //Metodo borrar
   
    public boolean borrar (Computadoras obj){
     return getComputadoras().remove(obj);
     
   
     
    }
   
    //Metodo buscar
    public boolean buscar (Computadoras obj){
    boolean test = false;
   
    if(this.getComputadoras().contains(obj))
    {
        test = true; 
    } 
   
    return test;
  }
 
  //Busca y devuelve un ordenador
  public Computadoras devuelOrdenador (String numero){
     
   Computadoras tempOrd, obj = null;
        boolean encontrado = false;
       
        Iterator it = this.getComputadoras().iterator();
        while (it.hasNext() && encontrado == false) {  //Para cortar el bucle
            tempOrd = (Computadoras) it.next();
           
            if (obj.getNumSerie().equalsIgnoreCase(numero)) {
                obj= tempOrd;
                encontrado = true;
            }
        }
        return obj;
    }
 
 
     //Metodo muestra 
 public void muestra(){
     Computadoras obj;
     Iterator itr = getComputadoras().iterator();
     while(itr.hasNext()){
         obj = (Computadoras)itr.next();
         obj.muestra();
         System.out.println("**************");
                   
     }
     
 }
 
 //Comprobamos que al menos hay 1 elemento
 public boolean AlgunElemento(){
    boolean algunElemento = false;
   
    if ( computadoras.size()>0){
        System.out.println (computadoras.size());
        algunElemento = true;
    }
    return algunElemento;
   
     
 }
 
 //Inicio Lista
 public boolean inicioLista(){
     
     boolean inicioLista = false;
     if (activo == 0){
         inicioLista = true;
     }
     
     return inicioLista;
 }
 //Comprobamos que estamos en el ultimo elemento
 public boolean finalLista (){
     boolean finalLista = false;
     
     if (activo == computadoras.size()){
         finalLista= true;
     }
     return finalLista;
 }
 
 
 //Comprobamos que hay almenos dos elementos para
 // dejar los botones de primero y ir a la derecha Enables
 public boolean botonesInferiores(){
  boolean inferior=  false;
 
     if (activo >= 0 ){
       inferior = true; 
     }
     
    return inferior;   
 }
 
 //Comprobamos que aun quedan por lo menos dos elementos
 // para dejear Enable el boton de ir a la izquierda
 public boolean botonesSuperiores(){
 boolean superior = false;
       
         if (activo < computadoras.size()){
             superior = true;           
         }
         
    return superior;
 }
 
 //Comprobamos que hay elementos en la lista
 //para la funcion limpiar
 public boolean elementosLista(){
    boolean elementosLista = false;
    int num = 0;
   
    num = computadoras.size();
    if (num>0){
        elementosLista= true;
       
    }
   return elementosLista;
     
 }
//clase   

    /**
     * @return the computadoras
     */
    public ArrayList<Computadoras> getComputadoras() {
        return computadoras;
    }

    /**
     * @param computadoras the computadoras to set
     */
    public void setComputadoras(ArrayList<Computadoras> computadoras) {
        this.computadoras = computadoras;
    }

    public int getActivo() {
        return activo;
    }

    public void setActivo(int activo) {
        this.activo = activo;
    }
   
   
   
}


Ahora te pongo la clase por ejemplo Sobremesa que extiende Computadoras;

Código: [Seleccionar]

public class SobreMesa extends Computadoras{
 
    private int numUsb;
    private boolean tSonido;
    private int tamanio;

    //Constructor
    public SobreMesa( String numSerie, String marca, String modelo, String micro, int memoria, boolean dvd, int numUsb, boolean tSonido, int tamanio) {
        super(numSerie, marca, modelo, micro, memoria, dvd);
        this.numUsb = numUsb;
        this.tSonido = tSonido;
        this.tamanio = tamanio;
    }

    //get y setters
    public int getNumUsb() {
        return numUsb;
    }

    public void setNumUsb(int numUsb) {
        this.numUsb = numUsb;
    }

    public boolean istSonido() {
        return tSonido;
    }

    public void settSonido(boolean tSonido) {
        this.tSonido = tSonido;
    }

    public int getTamanio() {
        return tamanio;
    }

    public void setTamanio(int tamanio) {
        this.tamanio = tamanio;
    }
   
   
    public void lee (){
       
    int numUsb;
    boolean tSonido;
    float tamanio;   
     
    numUsb = Integer.parseInt(Lector.leer(" Dime el numero de usb que tiene el ordenador"));
    tSonido = Boolean.parseBoolean(Lector.leer("Dime si tiene tarjeta de sonido \"true\" o no \"false\" "));
    tamanio = Float.parseFloat(Lector.leer("Dime el tamanio que tiene el monitor"));   
       
    }
   
   
   
   
    //metodo sobreescrito
   
    @Override
    String muestra() {
       return super.toString() +
               " Tiene " + numUsb + " USB, " + "\n" +
               " y " + tSonido + " tiene tarjeta sonido." + "\n" +
               "Su tamañio es; " + tamanio+ ".";
    }
   
    }


Vamos a la question, yo tengo un JFrame con botones que puedo ir hacía delante y atrás y se van mostrando los datos según, los comunes a Sobremesa y Portatiles, esos son fijos "cada modelo tiene los suyos claro" y luego los de cada clase segun portatíles o sobremesa.

Te pongo un método por que la clase es muy larga pero se ve claro a donde he tenido que ir. Fijate en las líneas que tienen comentario.

Código: [Seleccionar]


    private void b1derechaActionPerformed(java.awt.event.ActionEvent evt) {                                         
     
        //Cada vez que pulsamos el boton sumamos 1 a activo
        mostrar.setActivo(mostrar.getActivo()+1);
         Computadoras obj;
             
         if (!mostrar.finalLista()){   //Si no estamos en el último indice de la lista
             
          obj = (Computadoras)mostrar.getComputadoras().get(mostrar.getActivo());
         
          if (obj instanceof SobreMesa){
              label1.setText(obj.numSerie);
              label2.setText(obj.getMarca());
              label3.setText(obj.getModelo());
              label4.setText(obj.getMicro());
              String memoria = String.valueOf(obj.getMemoria());
              label5.setText(memoria);
              if (((SobreMesa)obj).getDvd()){  //Propiedad de objeto sobremesa inalcanzable para objeto Computadora
                  label6.setText("Si.");
              }else{
                  label6.setText("No.");
              }
              String usb=String.valueOf((((SobreMesa)obj).getNumUsb()));  //Propiedad de objeto sobremesa inalcanzable para objeto Computadora
              label7.setText(usb);
              if (((SobreMesa)obj).istSonido()){
              label8.setText("Si.");
          }else {
              label8.setText("No.");
         
          }
             String tamaño = String.valueOf(((SobreMesa)obj).getTamanio());  //Propiedad de objeto sobremesa inalcanzable para objeto Computadora
             label10.setText(tamaño);
             
          }
         
          if (obj instanceof Portatiles){
              label30.setText(obj.numSerie);
              label31.setText(obj.getMarca());
              label32.setText(obj.getModelo());
              label33.setText(obj.getMicro());
              String memoria = String.valueOf(obj.getMemoria());
              label34.setText(memoria);
              if (((Portatiles)obj).getDvd()){
                  label35.setText("Si.");
              }else{
                  label35.setText("No.");
              }
              String peso = String.valueOf(((Portatiles)obj).getPeso()); //Propiedad de objeto Portatiles inalcanzable para objeto Computadora
              label36.setText(peso);
              String pulgadas =  String.valueOf(((Portatiles)obj).getPulgadas()); //Propiedad de objeto Portatiles inalcanzable para objeto Computadora
              label37.setText(pulgadas);
          }
     
         } else{
             b1derecha.setEnabled(false);
             JOptionPane.showMessageDialog(this, "No hay más elementos a mostrar");
           
         }
         
         //Al pulsar la primera vez el boton de ir al siguiente objeto
         //Se activan los botones de retroceder y ir final.
         //Comprobamos que activo es mayor de 0
         if (mostrar.botonesInferiores()){
              b1final.setEnabled(true);
              b1izq.setEnabled(true);
      }
     
     
    }


Si tienes una solución estaría encantado que me lo dijeras por que cada vez que hago un array y tengo que separar cada tipo de objeto del array, se me cae el mundo encima.
Si haces un array que tiene 5 o 6 tipos de objetos para mostrar sus datos ....

Los métodos no hay problema si estan en la clase abtracta y los sobreescribes, pero si tienes un método propio, en este caso imagina Sobremesa que te devuelve (xxxxx), a no ser que haga el molde tampoco puedo acceder a ello.

De todas formas llevo poco tiempo con Java, posiblemente sea también problema de diseño 

[Mario R. Rancel]

Hola, si tienes una clase muy larga adjúntala como archivo pulsando debajo del editor del foro en "Opciones Adicionales".

No veo que te refieras a algo concreto, sino a nivel general a cómo acceder a propiedades o métodos específicos de subclases que no existen en las superclases. 

Podemos fijarnos en este código en concreto:

if (obj instanceof SobreMesa){ ..., pienso que sí puede ser correcto.

O fijarnos en este otro código:

if (((SobreMesa)obj).getDvd()){... una manera por la que podrías ahorrártelo sería definiendo el método getDvd en la superclase y sobreescribiéndolo en las subclases, aunque no sea aplicable a algunas de ellas. En caso de no ser aplicable puedes hacer que el método devuelva null. De ese modo podrías acceder como si se tratara de un método común.

El asunto es que de alguna manera vas a tener que identificar el subtipo concreto con el que estás trabajando o al menos si alguna de sus propiedades y métodos son null: por tanto vas a necesitar condicionales, posiblemente instanceof, posiblemente hacer uso de casting... Por tanto no veo que el enfoque que estás utilizando, a nivel general, sea malo. Sí veo algunas expresiones que parecen excesivamente complicadas y eso suele ser indicativo de mal diseño, pero tampoco puede valorarse sin hacer un análisis detallado que llevaría tiempo.

Esto a nivel general, en cuanto a diseño tendrás que irlo mejorando a medida que vayas adquiriendo más destreza en la programación java.


Nota: Hay un detalle que deberías mejorar al nombrar las clases: en vez de Computadoras, usar Computador. La clase define un tipo y responde a la pregunta ¿de qué tipo es este objeto? Respondemos mejor en singular que en plural: <<es de tipo Computador>>, no <<es de tipo Computadoras>>.

Saludos,

[gatoher]

Hola Mario, perdona por no responder antes. A ver, como me has respondido más o menos es asi como se trabaja. He estado viendo con Dongo el hacer un método generico, que reciva el array y luego con instanceof filtrar los objetos, "practicamente sería lo mismo que lo que yo he estado haciendo", por que dentro del método tienes que seguir filtrando por tipo de objeto.

Lo único, como tú comentas es sobreescribir los métodos implementados en la clase abstracta. Pero a mi me parece muy chocante tener que sobreescrivir métodos que no tienen nada que ver una clase con otra. Por ejemplo devolver el tamaño de la pantalla, o su peso son propiedades que si tiene un portatil y no un PC de sobremesa, o número de cds que tiene un PC de sobremesa y que no tiene un portatil, etc, etc.

Osea que llenar la clase abstracta o principal de todos los métodos no me termina de convencer. En mi clase hubo gente que en lugar de tener un único array de Computadoras hizo dos arrays "de computadoras" pero uno para portatiles otro para sobremesa. Pero tampoco me convence.

Como estoy viendo no hay una solución facíl.