PROGRAMACIÓN DE COMPUTADORES II
SEMANA 8
1
ÍNDICE HERENCIA ...................................................................................................................................... 3 1. INTRODUCCIÓN..................................................................................................................... 3 2. EJEMPLOS.............................................................................................................................. 5 2.1 EJEMPLO 1..................................................................................................................... 5 2.2 EJEMPLO 2..................................................................................................................... 6 2.3 EJEMPLO 3..................................................................................................................... 7 2.4 EJEMPLO 4..................................................................................................................... 9 2.5 EJEMPLO 5................................................................................................................... 10 2.6 EJEMPLO 6................................................................................................................... 11 3. RESUMEN EJERCITATIVO..................................................................................................... 14 3.1 EJERCICIO 1.................................................................................................................. 1 4 3.2 EJERCICIO 2.................................................................................................................. 1 6 4. REFERENCIAS BIBLIOGRÁFICAS ........................................................................................... 1 6
|
2
HERENCIA 1. INTRODUCCIÓN En esta clase se revisará el último concepto y uno de los más importantes de la Programación Orientada a Objetos, este es, la Herencia entre Clases. La idea básica es poder crear clases basadas en otras clases ya existentes, esto implica que se puede re-usar códigos (métodos y campos) definidos en otra clase existente. La herencia es una forma de abstracción, esto es, primero se centra en la definición general, luego, en los tipos específicos, por ejemplo, se piensa en un vehículo y después en sus subtipos (autos, buses, etc.). Se puede, entonces, especificar que existirán clases de tipo superior que son las que contienen las características generales de un objeto, y existirán clases específicas de este tipo de objeto que contienen sólo las características que las distinguen, porque heredan de la clase superior las características comunes. A la clase superior se le llama comúnmente superclase, clase base o clase padre , y a la nueva clase se le llama subclase, clase derivada o clase hija. Examinar el siguiente ejemplo:
Fuente: Lagos, R. (2008). Fundamentos de Programación Orientada a Objetos. p. 36.
En la figura se muestran 2 clases, EMPLEADO y PROFESOR, donde PROFESOR es un tipo especial de EMPLEADO, por lo tanto, se puede decir que todo EMPLEADO posee un nombre y un salario, pero un PROFESOR posee un nombre y un salario porque es un EMPLEADO y, además, contiene horas lectivas, que es una característica específica del tipo de EMPLEADO PROFESOR.
|
3
En este ejemplo se puede establecer que la Clase Profesor HEREDA de la Clase Empleado los atributos NOMBRE y SALARIO. Entonces, se puede decir que la HERENCIA es una forma de modularizar, eso dado que permite la redefinición de métodos. Sin embargo, es posible también agregar métodos y variables para adaptar la clase a la nueva situación. Java también permite consultar por la estructura de una clase (cuáles son sus métodos y variables). A esto se le llama reflexión. En la redefinición se mantiene el interfaz del método y cambia la implementación; esto es un ejemplo simple de polimorfismo (un interfaz y múltiples implementaciones). Para realizar estas operaciones podemos usar uno de dos tipos distintos, estos son:
Redefinición completa: no uso el servicio base. Redefinición parcial: uso el servicio de la clase base.
Esta situación es mostrada a modo de ejemplo en la siguiente figura.
Fuente: Lagos, R. (2008). Fundamentos de Programación Orientada a Objetos. p. 36.
Cuando se desea acceder al método de la clase base, se hace utilizando la palabra súper como referencia a los atributos del padre. De esta misma forma se puede acceder a los constructores de la clase base. Para definir una subclase a partir de otra se realiza de la siguiente forma:
class Manager extends Employee { .... } Fuente: Irigoyen, L. (2011). Programación de Computadores II. IACC.
|
4
Se define el nombre de la clase que se está creando (en el caso del ejemplo es la clase Manager), seguida de la palabra reservada EXTENDS (que significa que heredará de la clase, en este ejemplo, EMPLOYEE).
2. EJEMPLOS Revisar los ejemplos que se muestran a continuación:
2.1 EJEMPLO 1 En una empresa existen diferentes tipos de empleados, estos son, administradores, secretarias y programadores, pero además dentro de los administradores existen también los ejecutivos. Estas relaciones son graficadas en el siguiente diagrama.
Fuente: González, A. Diseño y Programación Orientados a Objetos. p. 5.
class Employee { ..... } class Manager extends Empl oyee { .... } De esta manera se define la superclase EMPLEADO y la subclase ADMINISTRADOR como extensión de EMPLEADO. Con el siguiente código se crean las instancias de EMPLEADO y ADMINISTRADOR.
Employee e; e=new Employee(...); // instancia e=new Manager(..); // OK. Subtitución
|
5
En el primer caso a través de e se tiene acceso a todo lo correspondiente a un EMPLEADO. En el segundo caso se tiene acceso a todo lo correspondiente a EMPLEADO, pero con la implementación de un ADMINISTRADOR. Al revés no es válido, porque toda referencia a MANAGER debe disponer de todos los campos.
2.2 EJEMPLO 2 Se pide desarrollar un programa en Java que permita, a través de un hilo, ejecutar un proceso que contabilice números desde el 1 hasta el 10 y vaya mostrando por pantalla dichos números, y que tenga un tiempo de retardo de 1000 milisegundos en pasar de un número al otro.
Fuente: Petrlik A., I. (2008). Lenguaje de programación V . p.31.
|
6
Fuente: Petrlik A., I. (2008). Lenguaje de programación V . p. 32.
2.3 EJEMPLO 3 Se pide desarrollar un programa en Java que permita, a través de un hilo, ejecutar un proceso de tiempo en segundos, donde al cabo de cierto tiempo (segundos) ingresado por teclado pueda mostrar un mensaje de la siguiente manera: “EL TIEMPO ES X MIN CON Y SEG”.
|
7
Fuente: Petrlik A., I. (2008). Lenguaje de programación V . p. 38.
|
8
2.4 EJEMPLO 4 Se pide desarrollar un programa en Java que permita, a través de dos hilos no sincronizados, mostrar una serie de mensajes, como se observa en la siguiente figura:
Fuente: Petrlik A., I. (2008). Lenguaje de programación V . p. 42.
Fuente: Petrlik A., I. (2008). Lenguaje de programación V . p. 42.
|
9
2.5 EJEMPLO 5 El siguiente código contiene la implementación de la clase COCHE; a modo de práctica genere usted las clases camión, autobús y automóvil heredando las características de COCHE.
Class Coche { private String marca; private int precio; public Coche (String marca, int precio){ this.marca = marca; this.precio = precio; } public int getPrecio(){ return precio; } public String getMarca(){ return marca; } public boolean equals (Object obj){ Coche otro = (Coche) obj; return (otro.getPrecio()==this.precio)&&(otro.getMarca().equals(this.marca); } protected Object clone(){ return new Coche (marca, precio); } public String toString (){ return “(“+marca+”,”+precio+”)”; } public static void main (String args[]){ Coche micoche = new Coche (“bmw”,100); Coche otrocoche = new Coche (“seat”,10); if (micoche.equals(otrocoche)) System.out.println(“iguales”); System.out.println(micoche); } Fuente: Irigoyen, L. (2011). Programación de Computadores II, IACC.
|
10
2.6 EJEMPLO 6 En el siguiente ejemplo se detalla paso a paso la creación de clases y métodos para administrar ciertos tipos de operaciones de cuentas de un banco. Con el objetivo de poder sintetizar todo lo aprendido hasta hoy se requiere analizar el código mostrado a continuación y luego realizar los siguientes ejercicios. •
•
Ejercicio1: crear la clase CCuentaCorriente que herede de CCuenta y que ingrese nombre, número de la cuenta corriente, y un giro de 300000. Ejercicio 2: modificar la clase Test para que el ingreso de los datos se haga por teclado.
public class Test { public static void main(String[] args) { // cuando se crea objeto cuenta01 llama al // constructor CCuenta // sin parámetros // comentar línea de abajo para mostrar efecto de herencia //CCuenta cuenta01 = new CCuenta(); // para efecto de herencia digitar esta línea de abajo CCuentaAhor ro cuenta01 = new CCuentaAhorr o(); // Al crear la cuenta01 a parti r de la cuenta de ahor ro se están //tomando todos los atributos de cuenta, ya que cuenta de ahorro //herede todo desde cuenta // cuando se crea objeto cuenta02 llama al constructor // CCuenta con parámetros CCuenta cuenta02 = new CCuenta("Eduardo", "ALFA", 999999, 3.5); // se envían los mensajes a la clase CCuenta cuenta01.asign arNombre("Un Nombre Cualquiera" ); cuenta01.asign arCuenta("Una Cuenta Cualquiera" ); cuenta01.asignarTipoDeInteres(2.5); cuenta01.ingreso(1000000); cuenta01.reintegro(500000); // Mostrar resultados de las operaciones // Recepción de mensajes desde métodos de la clase CCuenta de acuerdo a los //resultados de las ejecuciones de cada método. System.out.println(cuenta01.obtenerNombre()); System.out.println(cuenta01.obtenerCuenta()); |
11
System.out.println(cuenta01.estado()); System.out.println(cuenta01.obtenerTipoDeInteres()); System.out.println(); System.out.println(cuenta02.obtenerNombre()); System.out.println(cuenta02.obtenerCuenta()); System.out.println(cuenta02.estado()); System.out.println(cuenta02.obtenerTipoDeInteres()); } } // En esta clase se muestr a el resultado de herencia entre clases publ ic cl ass CCuentaAhorr o extends CCuenta { } public class CCuenta { // Esta será la superclase en la que se encuentran definidos los atributos y los //métodos que posteriormente serán heredados por la clase cuenta de ahorro. // definición de atributos private String nombre; private String c uenta; private double saldo; private double tipoDeInteres; // constructor CCuenta tiene sobrecarga esto significa que tiene redefinición de // métodos // se define el constructor de la clase CCuenta sin parámetros publ ic CCuenta() { System.out.println("Objeto CCuenta creado"); // esto s e origi na cuando main c rea objeto cuenta01 } // Se define el constructor de la clase CCuenta con parámetros public CCuenta(String nom, String cue, double sal, double tipo) { // inicia los atributos de cada nuevo objeto con unos // valores determinados, pasados como argumentos al // instante en que se solicita crear un objeto en la // clase Test asignarNombre(nom); asignarCuenta(cue); ingreso(sal); asignarTipoDeInteres(tipo); } // Definición de métodos // Valida si se ha enviado un nombre válido, de no ser así retorna un error public void asignarNombre(String nom) { // validamos el no mbr e que llega
|
12
if(nom .length()== 0) { System.out.println(" Error: No hay nombre"); return; } // Si el nombre es correcto, asignamos el nombre que llega al atributo nombre nombre = nom; } // Retorna el nombre recibido public String obtenerNombre() { return nombre; } //Valida que ha recibido una cuenta válida, esto en el caso que el largo de la // cuenta sea mayor a cero. public void asignarCuenta(String cue) { if(cue.length()== 0) { System.out.println(" Error: cuenta no valida"); return; } // Si la cuenta es válida, asignamos cuenta que llega al atributo cuenta cuenta = cue; } // Retorna la cuenta obtenida public String obtenerCuenta() { return c uenta; } // Retorna el saldo si es mayor a cero public double estado() { return saldo; } public void in greso(double cantidad) { if(canti dad < 0) { System.out.println(" Error: cantidad negativa"); return; } // sume cantidad a saldo saldo += canti dad; } public void r eintegro(double cantidad) {
|
13
if(saldo - cantidad < 0) { System.out.println(" Error: no dis pone de saldo"); return; } // reste al saldo actual la cantid ad saldo -= canti dad; } // Define el tipo de interés public void asignarTipoDeInteres(double tipo) { if(ti po < 0) { System.out.println(" Error: tipo no valido" ); return; } // asign ar tipo al tipo DeInteres tipoDeInteres = tipo; } public double obtenerTipoDeInteres() { return tipoDeInteres; } // añadir método main que incluya el código // del programa crear objetos CCuenta y realizar // operaciones con ellos } Fuentes: Klagges, E. (2010). Programación Orientada a Objetos. p. 4.
3. RESUMEN EJERCITATIVO En este punto se presentan ejercicios que harán posible la integración paulatina de los conocimientos adquiridos a lo largo del curso.
3.1 EJERCICIO 1 Confeccione el diagrama de Clases del código Java entregado.
|
14
import java.util.Scanner; public class Proc_Metodo { private int promedio = 0;// variable atributo de la clase para guardar el promedio public static void main(String args[]) { int numero1 = 0; int numero2 = 0; int numero3 = 0; // declarar variable que controle el ciclo int ciclo = 0; // crear variable receptora del promedio int rec_promedio = 0; // instanciar un objeto para la clase actual Proc_Metodo objeto = new Proc_Metodo(); while (ciclo < 3) { // proceso de ingreso de datos Scanner teclado = new Scanner(System.in); /* declarar la variable que guardará el dato * ingresado por teclado */ int numero = 0; System.out.print("Ingrese Numero: "); numero = teclado.nextInt(); // distribución de números ingresados if(ciclo == 0) numero1 = numero; if(ciclo == 1) numero2 = numero; if(ciclo == 2) numero3 = numero; // incrementar la variable del ciclo ciclo++; if(ciclo == 3) // llamar al método retornarPromedio rec_promedio = objeto.retornarPromedio(numero1, numero2, numero3); }// cierre ciclo while // imprimir el promedio de los números System.out.println("Promedio = "+rec_promedio); }// cierre del método main public int retornarPromedio(int numero1, int numero2, int numero3)
|
15
{ promedio = (numero1 + numero2 + numero3) / 3; return promedio;// devuelve el promedio }// cierre del método retornarPromedio }// cierre de la clase Fuente: Irigoyen, L. (2011). Programación de Computadores II. IACC.
3.2 EJERCICIO 2 Modele las clases que se piden usando gráfica UML, de acuerdo a lo solicitado. a) Se tiene una clase pública de nombre Proceso, con los atributos privados de tipo int, fecha de tipo date, duración de tipo float y con los siguientes métodos de tipo void y públicos: iniciar, suspender, abortar, terminar. b) Se tiene una clase pública de nombre Inicio, y que tiene dentro de ella sólo el método main de tipo estático, void y público.
4. REFERENCIAS BIBLIOGRÁFICAS González, A. J. (s.f.). Diseño y Programación Orientados a Objetos. Universidad Federico Santa María. Recuperado el 10 de abril de 2011, de http://www.google.cl/#hl=es&source=hp&biw=1276&bih=584&q=ppt+Dise%C3%B1o+ y+programaci%C3%B3n+orientados+a+objetos+Agust%C3%ADn+J.+Gonz%C3%A1lez% 2C+UTFSM&btnG=Buscar+con+Google&aq=f&aqi=&aql=&oq=&fp=fdfb608b8651229a
Lagos, R. (2008). Fundamentos de Programación Orientada a Objetos. Recuperado el 10 de abril de 2011, de http://www.google.cl/#hl=es&biw=1259&bih=584&q=ppt+Fundamentos+de+program aci%C3%B3n+orientada+a+objetos%2C+Ramiro+Lagos&aq=f&aqi=&aql=&oq=ppt+Dise
|
16
%C3%B1o+y+programaci%C3%B3n+orientados+a+objetos+Agust%C3%ADn+J.+Gonz% C3%A1lez%2C+UTFSM&fp=fdfb608b8651229a
Petrlik A., I. (2008). Lenguaje de programación V. Recuperado el 10 de abril de 2011, de http://www.google.cl/#hl=es&biw=1259&bih=584&sa=X&ei=Q0WiTaqHHPSw0QGw8SXBQ&ved=0CBEQBSgA&q=ppt+LENGUAJE+DE+PROGRAMACION+V+ING.CIP+.IVAN +PETRLIK+AZABACHE&spell=1&fp=fdfb608b8651229a
|
17
