Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Muchas gracias Alex! Me había olvidado de decir eso que tu aclaras.
Suerte repondiste por mí así quien lee este hilo lo encuentra completo.
Seguimos adelante! 

Muchas gracias Dan! A seguir adelante entonces!

Muchas gracias Alex!... Seguimos adelante! 

Mi versión del Ejercicio propuesto en la Entrega Nº94. Ejercicio CU00694B.

Define una clase Figura de la que hereden otras dos clases denominadas Cuadrado y Círculo. La clase figura debe tener al menos el campo dimensionPrincipal. Las clases Cuadrado y Círculo deben tener al menos un método calcularArea que permita calcular el área a partir de la dimensión principal, utilizando la fórmula matemática correspondiente. Además, sobreescribe el método equals para que dos cuadrados sean iguales si tienen igual dimensión principal, y dos círculos idem. A continuación crea un programa test donde crees varios círculos y cuadrados y hagas comprobaciones de igualdad usando el método equals.

Clase Figura
/**
 * Clase Figura
 *
 * @author (RaGa)
 * @version (20150428)
 */
public class Figura{
    // Declaración de campos de instancia.
    protected double dimensionPrincipal;

    /**
     * Constructor de clase
     */
    public Figura(double dimensionPrincipal){
        this.dimensionPrincipal=dimensionPrincipal;
    }

    /**
     * setters
     */
    public void setDimensionPrincipal(double dimensionPrincipal){
        this.dimensionPrincipal=dimensionPrincipal;
    }
   
    /**
     * getters
     */
    public double getDimensionPrincipal(){
        return dimensionPrincipal;
    }
   
    /**
     * método equals
     */
    public boolean equals(Object obj){
        if(obj instanceof Figura){
            Figura tmp=(Figura)obj;
            if(this.dimensionPrincipal==tmp.dimensionPrincipal){
                return true;
            }
            else{return false;}
        }
        else{return false;}
    }
   
   
} // fin de la clase
Clase Cuadrado
/**
 * Clase Cuadrado
 *
 * @author (RaGa)
 * @version (20150428)
 */
public class Cuadrado extends Figura{
    // Declaración de campos de instancia

    /**
     * Constructor de clase
     */
    public Cuadrado(int dimensionPrincipal){
        super(dimensionPrincipal);
    }

    /**
     * método calcularArea
     */
    public double calcularArea(){
        return (Math.pow(dimensionPrincipal,2));
    }
   
    /**
     * método equals
     */
   
    @Override
    public boolean equals(Object obj){
        if(obj instanceof Cuadrado){
            return super.equals(obj);
        }
        else{return false;}
    }
Clase Circulo
/**
 * Clase Circulo
 *
 * @author (RaGa)
 * @version (20150428)
 */
public class Circulo extends Figura{
    // Declaración de campos vacía

    /**
     * Constructor de clase
     */
    public Circulo(int dimensionPrincipal){
        super(dimensionPrincipal);
    }

    /**
     * método calcularArea
     */
    public double calcularArea(){
        return (Math.PI*Math.pow(dimensionPrincipal,2));
    }
   
    /**
     * método equals
     */
   
    @Override
    public boolean equals(Object obj){
        if(obj instanceof Circulo){
            return super.equals(obj);
        }
        else{return false;}
    }
       

   
} // fin de la clase
Clase TestFigura
/**
 * Clase TestFigura
 *
 * @author (RaGa)
 * @version (20150428)
 */
public class TestFigura{
    // Declaración de campos de clase vacía
 
    /**
     * Constructor de clase vacío
     */
    public TestFigura(){
    }

    /**
     * método main
     */
    public static void main(String[] args){
       
        // Creacion de los objetos
        Figura cuadrado1 = new Cuadrado(5);
        Figura cuadrado2 = new Cuadrado(8);
        Figura cuadrado3 = new Cuadrado(5);
       
        Figura circulo1 = new Circulo(7);
        Figura circulo2 = new Circulo(8);
        Figura circulo3 = new Circulo(7);
       
        // Comparación de objetos
        System.out.println("\fCOMPARACION ENTRE CUADRADOS");
        System.out.println("¿Es cuadrado1 igual a cuadrado2? "+cuadrado1.equals(cuadrado2));
        System.out.println("¿Es cuadrado1 igual a cuadrado3? "+cuadrado1.equals(cuadrado3));
        System.out.println("¿Es cuadrado2 igual a cuadrado3? "+cuadrado2.equals(cuadrado3));
        System.out.println("");
        System.out.println("COMPARACION ENTRE CÍRCULOS");
        System.out.println("¿Es circulo1 igual a circulo2? "+circulo1.equals(circulo2));
        System.out.println("¿Es circulo1 igual a circulo3? "+circulo1.equals(circulo3));
        System.out.println("¿Es circulo2 igual a circulo3? "+circulo2.equals(circulo3));
        System.out.println("");
        System.out.println("COMPARACION ENTRE UN CUADRADO Y UN CÍRCULO DE IGUAL DIMENSION PRINCIPAL");
        System.out.println("¿Es circulo2 igual a cuadrado2? "+circulo1.equals(cuadrado2));
       
    } // fin del main
       

   
} // fin de la clase
Se sobreescribió el método equals en la clase Figura, en la clase Cuadrado y en la clase Circulo.

La justificación es por motivos de modularidad y posible expansión en el futuro.

La clase Figura tiene un solo campo y es el que se compara en el método equals correspendiente a esta clase.

Si en el futuro se ampliara la cantidad de campos de la clase Figura y se  estableciera como criterio de igualdad para todos los objetos Figura (además del campo dimensión principal) que fuera necesaria la igualdad de algún otro campo, dicha comparación se incluiría en esta clase.

De esta manera, no se repetiría código en cada una de las subclases que pudiera tener la clase Figura.

A su vez, cada subtipo sobreescribe el método equals lo cual les  permite:

*) Primero establecer si lo que se están comparando son figuras del mismo tipo.
Si no estableciéramos esta comparación previa y solo usáramos el método equals de la superclase, obtendríamos un 'true' si comparamos un cuadrado y un círculo con la misma valor de campo dimension principal.

*) Cada método sobreescrito equals de cada subclase llama al método equals de la superclase para comprobar si cumple todos los requisitos de igualdad de la superclase Figura. (Hoy es un solo criterio, pero pueden ser muchos).

*) Pero además es necesario que cada subclase sobreescriba el método equals para poder establecer (en un futuro) criterios de igualdad que no son comunes a todos los objetos tipo Figura.

Por ejemplo: si en una posible ampliación de código, la clase Figura incorporara el campo 'color', y el criterio de color no fuera una condicion de igualdad para la clase Cuadrado pero sí para los objetos tipo Circulo, estableceríamos esa comparación del color en el método equals de la clase Circulo.

Mi versión del Ejercicio propuesto en la Entrega Nº92. Ejercicio CU00692B.

Clase Profesor
/**
 * Clase Profesor
 *
 * @author (RaGa)
 * @version (20150427)
 */
public class Profesor
{
    // Declaración de campos de instancia.
    private String nombre;
    private int edad;
    private int añosConsolidados;

    /**
     * Constructor 1 para objetos de clase Profesor
     */
    public Profesor(String nombre, int edad, int añosConsolidados){
        this.nombre=nombre;
        this.edad=edad;
        this.añosConsolidados=añosConsolidados;
    }
   
    /**
     * Constructor 2 para objetos de clase Profesor
     */
    public Profesor(){
        nombre="";
        edad=0;
        añosConsolidados=0;
    }

    /**
     * métodos setters
     */
   
    public void setAñosConsolidados(int añosConsolidados){
        this.añosConsolidados=añosConsolidados;
    }
   
    public void setNombre(String nombre){
        this.nombre=nombre;
    }
   
    public void setEdad(int edad){
        this.edad=edad;
    }
   
    /**
     * métodos getters
     */
   
    public int getAñosConsolidados(){
        return añosConsolidados;
    }
   
    public String getNombre(){
        return nombre;
    }
   
    public int getEdad(){
        return edad;
    }
   
    /**
     * métodos varios
     */
   
    public String mostrarDatos(){
        return ("\nNombre: "+nombre+", Edad: "+edad+", Años Consolidados: "+añosConsolidados+", ");
    }
   
    public double obtenerSalarioBase(){
        return (725+(añosConsolidados*33.25));
    }
   
}// fin de la clase

Clase ProfesorEmerito
/**
 * Clase ProfesorEmerito
 *
 * @author (RaGa)
 * @version (20150427)
 */
public class ProfesorEmerito extends Profesor
{
    // Declaración de campos de instancia.
    private int añosEmerito;

    /**
     * Constructor 1 para objetos de clase ProfesorEmerito
     */
    public ProfesorEmerito(String nombre, int edad, int añosConsolidados, int añosEmerito){
        super(nombre,edad,añosConsolidados);
        this.añosEmerito=añosEmerito;
    }
   
    /**
     * Constructor 2 para objetos de clase ProfesorEmerito
     */
    public ProfesorEmerito(int añosEmerito){
        super();
        añosEmerito=añosEmerito;
    }

    /**
     * métodos setters
     */
   
    public void setAñosEmerito(int añosEmerito){
        this.añosEmerito=añosEmerito;
    }
   
    /**
     * métodos getters
     */
   
    public int getAñosEmerito(){
        return añosEmerito;
    }

   
    /**
     * métodos varios
     */
   
    public String mostrarDatos(){
        return (super.mostrarDatos()+" Años Emérito: "+añosEmerito+", ");
    }
   
    public double obtenerSalarioBase(){
        return (super.obtenerSalarioBase()+(47.80*añosEmerito));
    }
   
}// fin de la clase

Clase TestHerencia6
import java.util.*;

/**
 * Clase TestHerencia6
 *
 * @author (RaGa)
 * @version (20150427)
 */
public class TestHerencia6
{
    // Declaracion de variables de instancia.
   

    /**
     * Constructor de clase
     */
    public TestHerencia6(){ //vacío
    }

    /**
     * método main
     */
    public static void main(){
        ArrayList<Profesor> listaProfesoresAcademia;
        listaProfesoresAcademia=new ArrayList<Profesor>();
       
        // Carga de datos de Profesores
        Profesor profe1 = new Profesor("Danilo Salazar Quintana",28,2);
        Profesor profe2 = new ProfesorEmerito("Cándido Tolosa Martínez",63,28,3);
        ProfesorEmerito profe3 = new ProfesorEmerito("María Rosa Díaz Díaz",60,27,2);
       
        // Carga de ListaProfesoresAcademia
        listaProfesoresAcademia.add(profe1);
        listaProfesoresAcademia.add(profe2);
        listaProfesoresAcademia.add(profe3);
       
        // Muestra de ListaProfesoresAcademia
        System.out.println("\fLista de Profesores de la Academia");
        for (Profesor tmp:listaProfesoresAcademia){
            System.out.println(tmp.mostrarDatos());
            System.out.println("Salario Base= "+tmp.obtenerSalarioBase());
        }
       
    }// fin de main
   
}// fin de clase


Muchas gracias Mario por las correcciones y por el aliento.

Veamos entonces...

La clase ListaDeEnvio tampoco tiene un nombre claro ni se le ve una funcionalidad clara. Si es simplemente para añadir un atributo, parece más lógico hacerlo en la superclase y en caso de no existir valor para dicho atributo mantenerlo vacio o como "Sin cliente"

Estoy totalmente de acuerdo!
En mi anterior versión había hecho la siguiente organización de herencias:

ListaDeProducto --> Lista <--- ListaDeEnvio

pensando que al haber aunque sea un campo diferente, debía (a los fines didácticos) armar una nueva clase hija. Pero ahora me doy cuenta con lo que me dices, que a la hora del buen diseño debo incluir ese campo en una misma clase, y luego sus instancias lo utilizarán o no.

La clase ListaDeProducto contiene solo un método cuya función es crear un producto de cualquier tipo, y tienes toda la razón en las observaciones que me haces sobre la misma. En esta nueva versión del ejercicio que les envío esta clase se renombró. Ya no es hija de nadie y se llama PreparadorDeProductos, siendo sus atributos ahora atributos de clase y no de instancia.

Volviendo entonces a la clase ListaDeEnvio: al haber incluído entonces el campo "extra" en la clase padre de la organización original, lo que me dices tu :

Si la clase Lista representa una lista de productos debería llamarse ListaDeProductos

ahora en la nueva versión lo que antes era la clase Lista se llama ListaDeProducto (no hereda a nadie, e incluye un campo que no siempre se utilizará). Desaparece la clase ListaDeEnvio.

Espero haber sido claro en los cambios 

Pongo nuevamente a disposicion el ejercicio para su corrección. Muchas gracias!

No por favor Alex, nada que perdonar, al contrario, soy yo (y seguramente muchos más) los que les agradecemos a uds. dediquen diariamente su tiempo en ayudarnos en nuestro aprendizaje.

Y es más, hasta podríamos considerar este hecho como algo positivo: ¡son personas reales! desconfiaba podrían ser una especie de "algoritmo corrector imbatible" jeje (una pequeña broma  ).

Muchas gracias, sigo adelante con las lecciones.

Muchas gracias Tony!, muchas gracias Alex!

Correcciones Tony:

... te habría quedado muy bien un menú en el main para poder añadir productos a discreción.

Si, pienso incorporar un Menú en ejercicios siguientes. Lo había pensado para este mismo, pero no quise complicar su corrección, y centrar el foco más bien en los conceptos de herencia. Pero me interesa mucho hacer los proyectos "amigables" con el usuario.

Ah, un buen truco la clase Exibidor. Los métodos que tiene son sencillos pero facilitan adornar la salida por consola.

La clase Exibidor la había creado en el ejercicio anterior y la volví a emplear en este nuevo ejercicio, aunque solo utilizo uno de sus métodos esta vez.

Correcciones Alex:

...aunque tuvieras razones como programador, la programación no debe ir en contra de la lógica del mundo real. En este caso si un producto refrigerado heradara de un producto congelado significaría que un producto refrigerado es un tipo de producto congelado...

El diseño tiene un fallo grave: no existe una clase Producto, de la cual deben heredar ProductoCongelado, ProductoRefrigerado y ProductoFresco.

Creo que pequé de querer "ahorrar" código dejando de lado lo que dices: "la programación no debe ir en contra de la lógica del mundo real ", y el concepto de que un padre hereda a sus hijos, por más que un hijo sea casi exactamente igual a su padre.

Agradeciéndoles el trabajo que se toman en corregirme, re subo el ejercicio en archivos adjuntos para su revisación. Muchas Gracias!

Perfecto Alex. Claro, no corresponden a atributos de instancia, no me daba cuenta de ello. Ya mismo modifico eso.
Muchas gracias por dedicar tu tiempo en estas correcciones, me ayudan mucho!

Mi versión del Ejercicio propuesto en la Entrega Nº86. Ejercicio CU00686B.

El código corre y hace lo que se pretende. Sin embargo -además de las observaciones que me harán- tengo una duda respecto a lo siguiente:

Dentro de la clase TestHerencia2 está el método main, y otros dos métodos. La incorporación de estos dos métodos es lo que "me hace ruido" en cuanto a la filosofía de la POO, ya que la clase GestionTipoProducto modifica campos del método main a través de esos dos métodos.

Hubiera preferido no tener que incluirlos pero me es inevitable a la hora de: no repetir código, y no declarar los campos (tmpString y tmpInt) como públicos.


Clase Producto

/**
 * Clase Producto.
 *
 * @author (RaGa)
 * @version (20150407)
 */
public class Producto
{
    // Declaración de campos de instancia.
    private String fechaDeCaducidad;
    private int nroLote;

    /**
     * Constructor de la clase Producto.
     *
     * Se iniciliza con dos parámetros:
     * fechaDeCaducidad (tipo String) que es la fecha de caducidad del producto.
     * nroLote (tipo int) que es el número de lote al que corresponde el producto.
     */
    public Producto(String fechaDeCaducidad, int nroLote){
        this.fechaDeCaducidad = fechaDeCaducidad;
        this.nroLote = nroLote;
    } // fin del constructor
   
//SETTERS//
   
    /**
     * Método setFechaDeCaducidad
     * Establece la fecha de caducidad del producto.
     *
     * @param fechaDeCaducidad representa la fecha de caducidad del producto.
     */
    public void setFechaDeCaducidad(String fechaDeCaducidad){this.fechaDeCaducidad = fechaDeCaducidad;}
   
    /**
     * Método setNroLote
     * Establece el número de lote del producto.
     *
     * @param nroLote representa el número de lote del producto.
     */
    public void setNroLote(int nroLote){this.nroLote = nroLote;}
   
//GETTERS// 
   
    /**
     * Método getFechaDeCaducidad
     * El método devuelve la fecha de caducidad del producto.
     *
     * @return retorna la fecha de caducidad del producto.
     */
    public String getFechaDeCaducidad(){return fechaDeCaducidad;}
   
    /**
     * Método getNroLote
     * El método devuelve el número de lote del producto.
     *
     * @return retorna el número de lote del producto.
     */
    public int getNroLote(){return nroLote;}
   
// MÉTODOS VARIOS //   

    /**
     * Método mostrarFechaDeCaducidad
     *
     * El método muestra la fecha de caducidad del producto.
     */
    public void mostrarFechaDeCaducidad(){System.out.print(fechaDeCaducidad+"\n");}
   
     /**
     * Método mostrarNroLote
     *
     * El método muestra el numero de lote del producto.
     */
    public void mostrarNroLote(){System.out.print(nroLote+"\n");}
   
   
   
}  // find e la clase


Clase ProductoFresco

/**
 * Clase ProductoFresco
 *
 * @author (RaGa)
 * @version (20150407)
 */
public class ProductoFresco extends Producto
{
    // Declaración de campos de instancia.
    private String fechaEnvasado;
    private String paisDeOrigen;   

    /**
     * Constructor de la clase ProductoFresco
     *
     * Se debe pasar como parámetro los campos de la superclase Producto.
     * Los campos específicos de esta clase son:
     * fechaEnvasado que representa la fecha de envasado del producto fresco (tipo String) y se inicializa como "desconocida".
     * paisDeOrigen que representa el país de origen del producto fresco (tipo String) y se inicializa como "desconocido".
     */
    public ProductoFresco(String fechaDeCaducidad, int nroLote){
        super (fechaDeCaducidad,nroLote);
        fechaEnvasado = "desconocida";
        paisDeOrigen = "desconocido";
    } // fin del constructor

//SETTERS//

    /**
     * Método setFechaEnvasado
     * Establece la fecha de envasado del producto fresco.
     *
     * @param representa la fecha de envasado del producto fresco.
     */
    public void setFechaEnvasado(String fechaEnvasado){this.fechaEnvasado = fechaEnvasado;}
   
     /**
     * Método setPaisDeOrigen
     * Establece el pais de origen del producto fresco.
     *
     * @param representa el pais de origen del producto fresco.
     */
    public void setPaisDeOrigen(String paisDeOrigen){this.paisDeOrigen = paisDeOrigen;}
   
//GETTERS// 
   
    /**
     * Método getFechaEnvasado
     * El método devuelve la fecha de envase del producto fresco.
     *
     * @return retorna la fecha de envase del producto fresco.
     */
    public String getFechaEnvasado(){return fechaEnvasado;}
   
     /**
     * Método getPaisDeOrigen
     * El método devuelve el pais de origen del producto fresco.
     *
     * @return retorna el pais de origen del producto fresco.
     */
    public String getPaisDeOrigen(){return paisDeOrigen;}
   
   
// MÉTODOS VARIOS //   

    /**
     * Método mostrarFechaEnvasado
     *
     * El método muestra la fecha de envasado del producto fresco.
     */
    public void mostrarFechaEnvasado(){System.out.print(fechaEnvasado+"\n");}

    /**
     * Método mostrarPaisDeOrigen
     *
     * El método muestra el pais de origen del producto fresco.
     */
    public void mostrarPaisDeOrigen(){System.out.print(paisDeOrigen+"\n");}
   
} // fin de la clase


Clase ProductoRefrigerado

/**
 * Clase ProductoRefrigerado
 *
 * @author (RaGa)
 * @version (20150407)
 */
public class ProductoRefrigerado extends Producto
{
    // Declaración de campos de instancia.
    private String codigoOSA;

    /**
     * Constructor de la clase ProductoRefrigerado
     *
     * Se debe pasar como parámetro los campos de la superclase Producto.
     * El campos específico de esta clase es:
     * codigoOSA que representa el código del organismo de supervisión alimentaria del producto refrigerado (tipo String) y se inicializa como "desconocido".
     */
    public ProductoRefrigerado(String fechaDeCaducidad, int nroLote){
        super (fechaDeCaducidad,nroLote);
        codigoOSA = "desconocido";
    } // fin del constructor

//SETTERS//

    /**
     * Método setCodigoOSA
     * Establece el código del organismo de supervisión alimentaria.
     *
     * @param representa el código del organismo de supervisión alimentaria.
     */
    public void setCodigoOSA(String codigoOSA){this.codigoOSA = codigoOSA;}
   
//GETTERS// 
   
    /**
     * Método getCodigoOSA
     * El método devuelve el código del organismo de supervisión alimentaria.
     *
     * @return retorna el código del organismo de supervisión alimentaria.
     */
    public String getCodigoOSA(){return codigoOSA;}
   
   
// MÉTODOS VARIOS //   

    /**
     * Método mostrarCodigoOSA
     *
     * El método muestra el código del organismo de supervisión alimentaria.
     */
    public void mostrarCodigoOSA(){System.out.print(codigoOSA+"\n");}   
   
} // fin de la clase


Clase ProductoCongelado

/**
 * Clase ProductoCongelado
 *
 * @author (RaGa)
 * @version (20150408)
 */
public class ProductoCongelado extends Producto
{
    // Declaración de campos de instancia.
    private int tempCongelacionRecomendada;
   
    /**
     * Constructor de la clase ProductoCongelado
     *
     * Se debe pasar como parámetro los campos de la superclase Producto.
     * El campo específico de esta clase es:
     * tempCongelacionRecomendada que representa la temperatura de congelación recomendada (tipo int) y se inicializa como -500.
     */


    public ProductoCongelado(String fechaDeCaducidad, int nroLote){
        super (fechaDeCaducidad,nroLote);
        tempCongelacionRecomendada = -500;
    } // fin del constructor

//SETTERS//

    /**
     * Método setFechaEnvasado
     * Establece la temperatura de congelación recomendada.
     *
     * @param representa la temperatura de congelación recomendada.
     */
    public void setTempCongelacionRecomendada(int tempCongelacionRecomendada){this.tempCongelacionRecomendada = tempCongelacionRecomendada;}
   
//GETTERS// 
   
    /**
     * Método getTempCongelacionRecomendada
     * El método devuelve la temperatura de congelacion recomendada.
     *
     * @return retorna la temperatura de congelacion recomendada.
     */
    public int getTempCongelacionRecomendada(){return tempCongelacionRecomendada;}

   
// MÉTODOS VARIOS //   

    /**
     * Método mostrarTempCongelacionRecomendada
     *
     * El método muestra la temperatura de congelacion recomendada.
     */
    public void mostrarTempCongelacionRecomendada(){System.out.print(tempCongelacionRecomendada);}     

   
} // fin de la clase


Clase TestHerencia2


/**
 * Clase TestHerencia2.
 * Esta clase sirve para probar nuestro incipiente incursión en el tema Herencia de Java.
 *
 * @author (RaGa)
 * @version (20150408)
 */
public class TestHerencia2{
   
    // Declaración de campos de instancia
    static String tmpFechaDeCaducidad;
    static int tmpNroLote;


    /**
     * Constructor de la clase TestHerencia2 vacío.
     */
    public TestHerencia2(){
    }

    /**
     * Método main.
     */
    public static void main (String[] args){
        // Declaración de los campos de clase
        String tmpString;
        int tmpInt;

//CARGA DE PRODUCTOS       
        System.out.print("\fBienvenido a la carga de Productos Alimenticios!\n");
        //Carga de un Producto Fresco
        Exibidor.mostrarEncabezadoProductoTipo("Fresco");
        GestorTipoProducto.pedirCampos();
        ProductoFresco miProductoFresco = new ProductoFresco(tmpFechaDeCaducidad,tmpNroLote);
        System.out.println("Por favor ingrese la fecha de envasado:");
        miProductoFresco.setFechaEnvasado(GestionadorEntradasTeclado.leerString());
        System.out.println("Por favor ingrese el país de origen del producto:");
        miProductoFresco.setPaisDeOrigen(GestionadorEntradasTeclado.leerString());
 
        //Carga de un Producto Refrigerado
        Exibidor.mostrarEncabezadoProductoTipo("Refrigerado");
        GestorTipoProducto.pedirCampos();
        ProductoRefrigerado miProductoRefrigerado = new ProductoRefrigerado(tmpFechaDeCaducidad,tmpNroLote);
        System.out.println("Por favor ingrese el Código del organismo de supervisión alimentaria:");
        miProductoRefrigerado.setCodigoOSA(GestionadorEntradasTeclado.leerString());
       
        //Carga de un Producto Congelado
        Exibidor.mostrarEncabezadoProductoTipo("Congelado");
        GestorTipoProducto.pedirCampos();
        ProductoCongelado miProductoCongelado = new ProductoCongelado(tmpFechaDeCaducidad,tmpNroLote);
        System.out.println("Por favor ingrese la temperatura de congelación recomendada:");
        miProductoCongelado.setTempCongelacionRecomendada(GestionadorEntradasTeclado.leerInt());

// MUESTRA DE PRODUCTOS CARGADOS
        System.out.println("\fProductos Alimenticios cargados por el sistema");
       
        //Muestra del Producto Fresco cargado
        Exibidor.mostarRotuloProductoTipo("Fresco");
        System.out.print("Fecha de caducidad: "); miProductoFresco.mostrarFechaDeCaducidad();
        System.out.print("Nro.de Lote: "); miProductoFresco.mostrarNroLote();
        System.out.print("Fecha de Envasado: "); miProductoFresco.mostrarFechaEnvasado();
        System.out.print("País de Origen: "); miProductoFresco.mostrarPaisDeOrigen();
       
       
        //Muestra del Producto Refrigerado cargado
        Exibidor.mostarRotuloProductoTipo("Refrigerado");
        System.out.print("Fecha de caducidad: "); miProductoRefrigerado.mostrarFechaDeCaducidad();
        System.out.print("Nro.de Lote: "); miProductoRefrigerado.mostrarNroLote();
        System.out.print("Código del organismo de supervisión alimentaria: "); miProductoRefrigerado.mostrarCodigoOSA();

        //Muestra del Producto Congelado cargado
        Exibidor.mostarRotuloProductoTipo("Congelado");
        System.out.print("Fecha de caducidad: "); miProductoCongelado.mostrarFechaDeCaducidad();
        System.out.print("Nro.de Lote: "); miProductoCongelado.mostrarNroLote();
        System.out.print("Temperatura de congelación recomendada: "); miProductoCongelado.mostrarTempCongelacionRecomendada();
       
    } // fin método main
   
   

     /**
     * Método cargarFechaCaducidadTipoProducto.
     * Sirve para cargar el campo tmpFechaDeCaducidad el cual servirá como parámetro para inicilizar un producto.
     *
     * @param Recibe como parámetro un String con la fecha de caducidad del producto.
     */
   
    public static void cargarFechaCaducidadTipoProducto(String valorTmpFechaDeCaducidad){
        tmpFechaDeCaducidad = valorTmpFechaDeCaducidad;
    }
   
     /**
     * Método cargarNroLoteTipoProducto.
     * Sirve para cargar el campo tmpNroLote el cual servirá como parámetro para inicilizar un producto.
     *
     * @param Recibe como parámetro un int con el numero de lote del producto.
     */
   
    public static void cargarNroLoteTipoProducto(int valorTmpNroLote){
        tmpNroLote = valorTmpNroLote;
    }   
   

   
} // fin de la clase


Clase GestorTipoProducto

/**
 * Clase GestorTipoProducto.
 *
 * Esta clase sirve para gestionar los parámetros necesarios para inicilizar un objeto tipo Producto.
 *
 * @author (RaGa)
 * @version (20150408)
 */
public class GestorTipoProducto{
   
    /**
    * Método pedirCampos.
    *
    * Esta método sirve para pedir al Usuario ingrese por Teclado los
    * parámetro que necesita el Constructor de la clase Producto.
    *
    */
    public static void pedirCampos(){
        System.out.println("Por favor ingrese la fecha de caducidad:");
        TestHerencia2.cargarFechaCaducidadTipoProducto(GestionadorEntradasTeclado.leerString());
        System.out.println("Por favor ingrese el número de lote:");
        TestHerencia2.cargarNroLoteTipoProducto(GestionadorEntradasTeclado.leerInt());
    } //fin de método

   
} // fin de clase

Clase Exibidor

/**
 * Clase Exibidor.
 *
 * Esta clase sirve mostrar datos por consola.
 *
 * @author (RaGa)
 * @version (20150408)
 */
public class Exibidor{
   
    /**
    * Método mostrarEncabezadoProductoTipo.
    *
    * Esta método sirve para mostrar el encabezado al momento de la carga de los productos.
    *
    * @param El parámetro de entrada corresponde al tipo de producto que se cargara (Congelado, Refrigerado, o Fresco). Este parámetro tipo String es el que se mostrará por consola.
    *
    */
    public static void mostrarEncabezadoProductoTipo(String tipoDeProducto){
        System.out.print("------------------------------------------------\n");
        System.out.print("");
        System.out.println("A continuación se cargará un Producto "+tipoDeProducto+"...");
        System.out.println("");
    } //fin de método
   
    /**
    * Método mostarRotuloProductoTipo.
    *
    * Esta método muestra por consola un encabezado donde se indica el tipo de Producto.
    *
    * @param El parámetro corresponde al tipo de producto (Congelado, Refrigerado, o Fresco).
    *
    */
    public static void mostarRotuloProductoTipo(String tipoDeProducto){
        System.out.println("------------------------------------------------\n");
        System.out.println("[ Producto "+tipoDeProducto+" ]");
        System.out.println("");
    } // fin de método 
   
   
} // fin de clase


Clase GestionadorEntradasTeclado

import java.util.Scanner;

/**Esta clase sirve para leer los valores ingresados por el usuario a través del teclado. Cuenta con dos métodos estáticos tipo función: uno devuelve un objeto tipo String ingresado por el usuario a través del teclado, y el otro devuelve un valor tipo int ingresado por el usuario a través del teclado.
 * @author: RaGa
 * @date: 15/03/15
 * @version: 01
 */

public class GestionadorEntradasTeclado{
    //Declaracion de campos de instancia de la clase vacío.
   
    public GestionadorEntradasTeclado(){ // Constructor de clase vacío.
    }
   
    /**Devuelve un objeto tipo String que corrsponde al valor ingresado por el usuario a través del teclado.
     * @return retorna un objeto tipo String.
     */
     public static String leerString(){
        Scanner scannerTeclado = new Scanner (System.in);
        String valorTeclado = scannerTeclado.nextLine();
        return valorTeclado;
    }
   
    /**Devuelve un valor tipo int que corresponde al valor ingresado por el usuario a través del teclado.
    * @return retorna un valor tipo int.
    */
    public static int leerInt(){
       Scanner scannerTeclado = new Scanner (System.in);
       int valorTeclado = scannerTeclado.nextInt();
       String valorTmp = scannerTeclado.nextLine(); // para vaciar el buffer.
       return valorTeclado;
    }
     
} // Fin de la clase