UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD

PROGRAMACION ORIENTADA A OBJETOS

FASE 4 – HERENCIA EN LENGUAJE DE PROGRAMACIÓN JAVA

PRESENTADO POR:
WILSON ANDRES PORTILLA GARCIA C.C. 1.123.304.174

GRUPO: 301403_36

TUTOR

FRANKLIN LIZCANO CELIS

UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA – UNAD

ESCUELA DE CIENCIAS BÁSICAS, TECNOLOGÍA E INGENIERÍA

MAYO2019
 Actividades a desarrollar

Cada estudiante consulta y entrega definición de los siguientes conceptos:

- Herencia: es crear una nueva clase que este heredada de una ya existente, lo cual ahorra
tiempo en la programación, ya que si contamos con una clase que se acerca a lo que
necesitamos; no es necesario crear una clase desde cero, podemos aprovecharla y extenderla
para crear nuestra nueva clase. Esta nueva clase se llamará subclase y la clase que ya teníamos
se llamará superclase.
La subclase heredara todos los atributos y los métodos que fueron definidos en la clase padre.

- Polimorfismo: es una técnica para optimizar la funcionalidad basada en tipos particulares.

La diferencia entre herencia y polimorfismo es que herencia está relacionada con clases y
polimorfismo con métodos.

- Herencia Simple: es la más común, se puede encontrar en cualquier lenguaje moderno

como Java o C#.

La herencia simple es una relación entre una clase padre (clase base) y una clase hija (clase
derivada) llamada "es un tipo de", que muchas veces se abrevia como isA.
La herencia es simple cuando la clase derivada que estamos considerando sólo tiene una clase
base.

- Herencia Múltiple: se encuentra en aquellos casos en los que una clase derivada tiene
varias clases base (al menos, más de una).

Un ejemplo típico sería una clase ProfesorUniversitario que heredara de las clases Profesor
e Investigador.
La clase Profesor declararía la información que deseamos conocer sobre los profesores: su
nombre y la materia que imparten.

- Herencia de Interfaz: las interfaces también pueden heredar de otras interfaces,

consiguiendo así una nueva interfaz, se emplea el extends habitual.
Teniendo así que la clase que implementa a esa nueva interfaz recibirá los métodos tanto de
la interfaz base como la derivada.

- Herencia de Implementación: Como ya se ha visto, las interfaces carecen de funcionalidad

por no estar implementados sus métodos, por lo que se necesita algún mecanismo para dar
cuerpo a sus métodos.

La palabra reservada implements utilizada en la declaración de una clase indica que la clase
implementa la interfaz, es decir, que asume las constantes de la interfaz, y codifica sus
métodos

- Polimorfismo y reutilización: se denomina polimorfismo a la capacidad del código de un

programa para ser utilizado con diferentes tipos de datos u objetos. También se puede aplicar
a la propiedad que poseen algunas operaciones de tener un comportamiento diferente
dependiendo del objeto (o tipo de dato) sobre el que se aplican.

El concepto de polimorfismo se puede aplicar tanto a funciones como a tipos de datos. Así
nacen los conceptos de funciones polimórficas y tipos polimórficos. Las primeras son
aquellas funciones que pueden evaluarse o ser aplicadas a diferentes tipos de datos de forma
indistinta; los tipos polimórficos, por su parte, son aquellos tipos de datos que contienen al
menos un elemento cuyo tipo no está especificado.

- Sobrecarga: se refiere a la posibilidad de tener dos o más métodos con el mismo nombre,
pero distinta funcionalidad. Es decir, dos o más métodos con el mismo nombre realizan
acciones diferentes y el compilador usará una u otra dependiendo de los parámetros usados.

Gracias a la sobrecarga de métodos, una clase puede tener distinto comportamiento

dependiendo de cual método sobrecargado se use, a esta característica se le conoce como
Polimorfismo por sobrecarga.

- Polimorfismo en jerarquías de herencia: consideremos las figuras planas cerradas como

el rectángulo, y el círculo. Tales figuras comparten características comunes como es la
posición de la figura, de su centro, y el área de la figura, aunque el procedimiento para
calcular dicha área sea completamente distinto. Podemos, por tanto, diseñar una jerarquía de
clases, tal que la clase base denominada Figura, tenga las características comunes y cada
clase derivada las específicas. La relación jerárquica se muestra en la figura

La clase Figura es la que contiene las características comunes a dichas figuras concretas por
tanto, no tiene forma ni tiene área. Esto lo expresamos declarando Figura como una clase
abstracta, declarando la función miembro area abstract.

Las clases abstractas solamente se pueden usar como clases base para otras clases. No se
pueden crear objetos pertenecientes a una clase abstracta. Sin embargo, se pueden declarar
variables de dichas clases.

- Variables Polimórficas: es una variable que contiene un objeto y se refiere al hecho de que
una misma variable puede contener objetos de diferentes tipos del tipo declarado o de
cualquier subtipo del tipo declarado por eso se llama polimórfica que literalmente significa:
muchas formas.
2. Cada estudiante realiza en un documento el modelo de herencia a aplicar en su proyecto.
En este modelo deben especificarse cada una de las clases según el modelo de clases de la
fase 2 y posteriormente implementar la herencia donde determine cuáles son las clases padre
que quedan y cuáles son las clases hijas que quedan junto con los atributos a heredar.
La clase padre sería Productos.java
1 //Wilson Andres Portilla
2 public class Productos {
3 private String nombre;
4 private float precio;
5 private String descripcion;
6
7 public Productos(){
8
9 }
10
11 public Productos(String nombre, float precio, String descripcion){
12 this.nombre = nombre;
13 this.precio = precio;
14 this.descripcion = descripcion;
15 }
16
17 public String getNombre() {
18 return nombre;
19 }
20
21 public void setNombre(String nombre) {
22 this.nombre = nombre;
23 }
24
25 public float getPrecio() {
26 return precio;
27 }
28
29 public void setPrecio(float precio) {
30 this.precio = precio;
31 }
32
33 public String getDescripcion() {
34 return descripcion;
35 }
36
37 public void setDescripcion(String descripcion) {
38 this.descripcion = descripcion;
39 }
40
41 @Override
42 public String toString() {
43 return "Productos{" + "nombre=" + nombre + ", precio=" + precio + ", descripci
44 + '}';
45 }
46
47 public float calcular(int cantidad_productos){
48
49 float fin = precio * cantidad_productos;
50 setPrecio(fin);
51 return fin;
52 }
53
54
55
}

La clase producto_no_perecedero.java herada de la clase Productos

1 //Wilson Andres Portilla

2 public class producto_no_perecedero extends Productos{
3 private int clave;
4
5 public producto_no_perecedero(){
6
7 }
8
9 public producto_no_perecedero(int clave, String nombre, float precio, String desc
10 super(nombre, precio, descripcion);
11 this.clave = clave;
12 }
13
14 public int getClave() {
15 return clave;
16 }
17
18 public void setClave(int clave) {
19 this.clave = clave;
20 }
21
22 @Override
23 public String toString() {
24 return "producto_no_perecedero{" + "clave=" + clave + '}';
25 }
26
27 public float calcular(int cantidad_productos){
28 System.out.println("No perecedero");
29 float fin = getPrecio() * cantidad_productos;
30 setPrecio(fin);
31 return fin;
32 }
33
34 }
La clase producto_perecedero.java herada de la clase Productos

//Wilson Andres Porilla

1 public class producto_precedero extends Productos{
2 private int dias_para_caducar;
3
4 public producto_precedero(){
5
6 }
7
8 public producto_precedero(int dias_para_caducar, String nombre, float precio, Str
9 descripcion){
10 super(nombre, precio, descripcion);
11 this.dias_para_caducar = dias_para_caducar;
12
13 }
14
15 @Override
16 public String toString() {
17 return "producto_precedero{" + "dias_para_caducar=" + dias_para_caducar + '}'
18 }
19
20 public int getDias_para_caducar() {
21 return dias_para_caducar;
22 }
23
24 public void setDias_para_caducar(int dias_para_caducar) {
25 this.dias_para_caducar = dias_para_caducar;
26 }
27
28 float precio_total = 0;
29 public float calcular(int cantidad_productos){
30 System.out.println("Perecedero");
31 float precio_final = super.calcular(cantidad_productos);
32 System.out.println("Precio total:"+precio_final +" \n * Aplicando descuento
33 caducidad...");
34 if(getDias_para_caducar() == 5){
35 precio_total = precio_final - (precio_final / 4);
36 setPrecio(precio_total);
37 }else if(getDias_para_caducar() == 15){
38 precio_total = precio_final - (precio_final / 3);
39 setPrecio(precio_total);
40 }else if(getDias_para_caducar() == 30){
41 precio_total = precio_final - (precio_final / 2);
42 setPrecio(precio_total);
43 }
44 return precio_total;
45 }
46
}
La clase ejecutable no hereda de nada, solo ejecuta el programa y es donde se crean los
objetos o instancias para darle utilidad a la herencia.

1 //Iván Luis Jiménez

2
3 public class ejecutable {
4
5 public static void main(String[] args){
6 Productos[] productos = new Productos[6];
7 productos[0] = new producto_precedero(5, "Capsu", 25, "Jugo rojo agridulce");
8 productos[1] = new producto_precedero(15, "Paleta", 12, "Dulce rojo");
productos[2] = new producto_precedero(30, "Dulce 2", 28, "Dulce 2 tambien");
9
productos[3] = new producto_no_perecedero(12, "Churrumais", 12, "Palitos de maiz");
10 productos[4] = new producto_no_perecedero(32, "Galletitas", 29, "Galletita abuelita");
11 productos[5] = new producto_no_perecedero(69, "Marias", 36, "Galletas marias");
12
13 for(int i = 0; i < productos.length; i++){
14 System.out.println("Precio del producto "+(i + 1) +" es "+ productos[i].
15 productos");
16 System.out.println("* Total a pagar: "+productos[i].calcular(5));
17 }
18 }
19 }