Universidad de Ibagué, Coruniversitaria.
Programa Ingeniería de Sistemas

Programación Orientada a Objetos

Inicio

Generalidades

Ejercicios

Talleres

Proyecto

Ejercicios "amistosos"

 Herencia

 La herencia o relación es-un es la relación que existe entre dos clases: una clase derivada que se crea a partir de otra ya existente, denominada clase base. Es decir, la nueva clase puede heredar de la clase ya existente. Por ejemplo, Programador es-un tipo de Empleado.  La clase base y la clase derivada tienen datos y operaciones comunes.


La herencia es uno de los conceptos más cruciales en la POO. La herencia básicamente consiste en que una clase puede heredar sus variables y métodos a varias subclases (la clase que hereda es llamada superclase o clase padre). Esto significa que una subclase, aparte de los atributos y métodos propios, tiene incorporados los atributos y métodos heredados de la superclase. De esta manera se crea una jerarquía de herencia.
Por ejemplo, imaginemos que estamos haciendo el análisis de un Sistema para una tienda que vende y repara equipos celulares.
http://java.ciberaula.com/imagenes/ciberaula/es/area/java/articulo/java_too_cinco.gif
En el gráfico vemos 2 Clases más que posiblemente necesitemos para crear nuestro Sistema. Esas 2 Clases nuevas se construirán a partir de la Clase Celular existente. De esa forma utilizamos el comportamiento de la SuperClase.
En general, podemos tener una gran jerarquía de Clases tal y como vemos en el siguiente gráfico:
http://java.ciberaula.com/imagenes/ciberaula/es/area/java/articulo/java_too_seis.gif

 

 Implementación de la Herencia en C+++
class Base
{
   private:
      int i;

   public:
      Base(int h){i=h;} //constructor
};

//A continuación, la subclase o clase derivada
class Subclase :  public Base
{
   Subclase(int u) : Base(u){};
};
 Implementación de la Herencia en JAVA
class Base{
   int i;
   Base(int h){i=h;}
};

class Subclase extends Base{
   Subclase(int u){
   super(u);}
};
 Implementación de la Herencia en PHP5
class Base{
   var $atributo1;
   function operacion1(){ }
}

class Subclase extends Base{
   var $atributo2;
   function operacion2(){}
}

 Otro ejemplo en lenguaje PHP

class cinta_video extends soporte{
   private $duracion;

   function __construct($tit,$num,$precio,$duracion){
      parent::__construct($tit,$num,$precio);
      $this->duracion = $duracion;
   }

   public function imprime_caracteristicas(){
      echo "Película en VHS:<br>";
      parent::imprime_caracteristicas();
      echo "<br>Duración: " . $this->duracion;
   }
}

Con la primera línea class cinta_video extends soporte estamos indicando que se está definiendo la clase cinta_video y que va a heredar de la clase soporte.

 
Nota: Como se está heredando de una clase, PHP tiene que conocer el código de la clase "padre", en este caso la clase soporte. De modo que el código de la clase soporte debe estar incluido dentro del archivo de la clase cinta_video. Podemos colocar los dos códigos en el mismo archivo, o si están en archivos independientes, debemos incluir el código de la clase soporte con la instrucción include o require de PHP.

 

<> Herencia en C++  

// El siguiente programa ilustra el uso de la herencia del C++
// construyendo la Clase profesor a partir de la Clase base persona.
// Programa: PERSONA.CPP

#include "iostream.h"
#include "string.h"
#include "conio.h"
#include "stdio.h"
#include "dos.h"
#define cls clrscr()
// La HERENCIA es la habilidad que tiene una Clase derivada de
// heredar las caracteristicas (datos y funciones) de una Clase base existente.
// Suponga, por ejemplo, que tiene la siguiente clase base:

class Persona{
   public:
      Persona(char *, char *, float);
      Persona(){ }
      void set_Persona();
      void get_Persona();
   protected:
      char nombre[50];
      char direc[40]; // direccion
   private:
      float estat; // estatura
};

Persona:: Persona(char *nombre, char *direc, float estat){
   strcpy(Persona::nombre, nombre);
   strcpy(Persona::direc, direc);
   Persona::estat = estat;
}

void Persona:: set_Persona(){
   cout << "Nombre : ";gets(nombre);
   cout << "Direccion: ";gets(direc);
   cout << "Estatura : ";cin >> estat;
}

void Persona:: get_Persona(){
   cout << "Nombre : " << nombre << endl;
   cout << "Direccion: " << direc << endl;
   cout << "Estatura : " << estat << endl;
}

// Ahora, suponga que su programa necesita una clase Profesor, que
// adiciona los siguientes datos miembros a la clase Persona: La
// palabra reservada public, que antecede al nombre de la clase
// Persona especifica que los miembros publicos dentro de la clase
// Persona tambien son publicos dentro de la clase Profesor. Las
// siguientes declaraciones derivan la clase Profesor:

class Profesor : public Persona{
   public:
      Profesor(char *,char *,char *,float,float,int);
      Profesor(){}
      void set_Profesor();
      void get_Profesor();
   private:
      float sueldo;
      char profes[25]; // Profesion
      int categ; // categoria
};

// Cuando derive una clase a partir de otra clase base, los miembros
// privados dentro de la clase base solamente son accesibles a la
// clase derivada a traves de las funciones de interfaz dentro de la
// clase base. Asi, la clase derivada no puede tener acceso a los
// miembros privados de la clase base utilizando el operador punto.

Profesor:: Profesor(char *nombre, char *direc, char *profes, float estat,
   float sueldo, int categ) : Persona(nombre,direc,estat){
   strcpy(Profesor::profes, profes);
   Profesor::sueldo = sueldo;
   Profesor::categ = categ;
};

void Profesor:: set_Profesor(){
   set_Persona(); // hereda funcion de la clase Persona
   cout << "Profesion: ";gets(profes);
   cout << "Sueldo $ ";cin >> sueldo;
   cout << "Categoria: ";cin >> categ;
}

void Profesor:: get_Profesor(){
   get_Persona(); // hereda funcion de la clase Persona
   cout << "Profesion: " << profes << endl;
   cout << "Sueldo $ " << sueldo << endl;
   cout << "Categoria: " << categ << endl;
}

// A continuacion se implementa la funcion principal

void main(){
     cls;
     // Se crean e inicializan los objetos Alumno y Profe.
     Persona Alumno("Ana Sofia Henao", "B/ El Poblado", 1.67);
     Profesor Profe("David Villalobos","Urb. Varsovia", "Ingeniero de Petroleos",
 1.75, 977000, 2);
     // Se crea un objeto con el segundo constructor de Profesor y se lee por teclado
     Profesor ProfeTc;
     cout << "Datos del PROFESOR" << endl << endl;
     ProfeTc.set_Profesor();

     cout << endl << "OBJETO ALUMNO" << endl;
     Alumno.get_Persona();
     sleep(3);
     cout << endl << "OBJETO PROFESOR" << endl;
     Profe.get_Profesor();
     sleep(5);
     cout << endl << "OBJETO PROFESOR TC" << endl;
     ProfeTc.get_Profesor();
     sleep(5);
}

// Práctica de POO:
// a) Realizar compilación separada de clases
// b) Leer un arreglo de  instancias de la clase Profesor
// c) Derivar la clase 'AlumnoMonitor' de la clase base persona.

----------------------------------------------------------------

  1.  Escriba un POO  para crear la clase Telefono y leer un arreglo de instancias de la clase derivada Celular. Implementar un método para calcular y visualizar el valor de la llamada según el operador (Valor minuto Comcel $1000, MoviStar $1200, Ola $700). Validar que se efectuó la llamada.

  2.  Crear una clase Publicación con el título, autor, año y precio de cada publicación y diseñar una clase derivada Disco, con duración en minutos, autor, género musical y precio. Cada clase tendrá una función leer( ) y otra función mostrar( ), para visualizar sus datos. Escribir un programa  que lea por teclado un arreglo de instancias de la clase derivada y después lo visualice.

  3.  Crear una clase Tarjeta y diseñar una clase derivada TarjetaCredito. Cada clase tendrá una función leer( ) y otra función mostrar( ), para visualizar sus datos. Escribir un programa que lea por teclado un arreglo de instancias de la clase TarjetaCredito y después lo visualice. Implementar también la función miembro avance_en_efectivo().

  4.  Crear en C++ la clase Empleado y derivar una clase Programador. Cada clase tendrá una función setDatos( ) y otra función getDatos( ). Escribir un POO que lea por teclado un arreglo de instancias de la clase derivada, implementar una función para actualizar la categoría del programador y después visualizar el vector.

  5.  Escribir un POO  para definir la clase Circulo y la clase Rectangulo, y crear una clase derivada Cilindro. Leer por teclado un arreglo de instancias de la clase heredada, implementar una función para calcular el volumen, y después visualizar el vector. (V = ת.r².h )

____________________________________________

<> Otros  'ejercicios amistosos'  aplicando Herencia:

  1. Implementar las Clases correspondientes a la jerarquía Barco, Velero, DeVapor y DeTurbinas. Crear objetos de las clases derivadas.

  2. Implementar la jerarquía de Clases para Prestamo, CompraAuto, CompraCasa, PagoEstudios  y  MejoraDeVivienda.

  3. Escribir un programa para representar las Clases de la jerarquía Figura, Cuadrado, Rectangulo, Triangulo, Circulo y Esfera.

  4. Una vista de los empleados de una empresa, basada en el modo de pago, puede dividir a los empleados con sueldo mensual fijo, empleados con pago por horas de trabajo y empleados con pago por comisión según las ventas realizadas. Implementar un arreglo de objetos de alguna de las Clases derivadas.

  5. Escribir un programa para representar las Clases de la jerarquía Credito, DeConsumo, Hipotecario y DeLibreInversion. Crear arreglos de objetos de las clases derivadas.

_____________________________________

 <> Herencia en JAVA

_____________________________________

 En Java se debe incluir la palabra reservada extends en la línea de la declaración de la clase derivada.  

// Herencialum.java
// Declaracion de clase base y clase derivada

import java.io.*;

class Persona{
   protected String nombre, direc, fechanac;

   public void setDatos(String nombre,String direc,String fechanac){
      this.nombre = nombre;
      this.direc = direc;
      this.fechanac= fechanac;
   }
   public void getDatos(){
      System.out.println("\nNombre : "+nombre);
      System.out.println("Direccion : "+direc);
      System.out.println("Fecha Nac.: "+fechanac);
   }
}

// Alumno se deriva de Persona
class Alumno extends Persona{
   private long codg;
   private String prog;

   public void setDatosAlum(long codg, String prog){
      this.codg = codg;
      this.prog = prog;
   }
   public void getDatosAlum(){
      System.out.println("\nCodigo : "+codg);
      System.out.println("Programa : "+prog);
   }
}

public class Herencialum{

   public static void main(String arg[]){

      Alumno Alum = new Alumno();
      Alum.setDatos("Laura Lucia Martinez H.","Varsovia II","27/11/1990");
      Alum.setDatosAlum(712008027,"Comunicacion Social y Periodismo");
      Alum.getDatos();
      Alum.getDatosAlum();
   }
}
// Derivar la clase Profesor y leer por teclado varios objetos de Alumno y Profesor

  1. Implementar las Clases correspondientes a la jerarquía Barco, Velero, DeVapor y DeTurbinas. Crear objetos de las clases derivadas.

  2. Implementar la jerarquía de Clases para Prestamo, CompraAuto, CompraCasa, PagoEstudios  y  MejoraVivienda.

  3. Escribir un programa para representar las Clases de la jerarquía Figura, Cuadrado, Rectangulo, Triangulo, Circulo y Esfera.

  4. Una vista de los empleados de una empresa, basada en el modo de pago, puede dividir a los empleados con sueldo mensual fijo, empleados con pago por horas de trabajo y empleados con pago por comisión según las ventas realizadas. Implementar un arreglo de objetos de alguna de las Clases derivadas.

  5. Escribir un programa para representar las Clases de la jerarquía Credito, DeConsumo, Hipotecario y DeLibreInversion. Crear arreglos de objetos de las clases derivadas.

____________________________________________

<> Otros  'ejercicios amistosos'  aplicando Herencia:

  6.  Crear una clase Publicación con el título, autor, año y precio de cada publicación y diseñar una clase derivada Disco, con duración en minutos, autor, género musical y precio. Cada clase tendrá un método leer( ) y otro método mostrar( ), para visualizar sus atributos. Escribir un programa  que lea por teclado un arreglo de instancias de la clase derivada y después lo visualice.

  7.  Escriba un POO  para crear la clase Telefono y leer un arreglo de instancias de la clase derivada Celular. Implementar un método para calcular y visualizar el valor de la llamada según el operador (Valor minuto Comcel $1000, MoviStar $1200, Ola $700). Validar que se efectuó la   llamada y mostrar el valor de la llamada más costosa indicando el operador correspondiente.

  8.  Crear una clase Tarjeta y diseñar una clase derivada TarjetaCredito. Cada clase tendrá un método leer( ) y otro método mostrar( ), para visualizar sus atributos. Escribir un programa que lea por teclado un arreglo de instancias de la clase TarjetaCredito y después lo visualice. Implementar también el método avance_en_efectivo().

  9.  Crear en Java la clase Empleado y derivar una clase Programador. Cada clase tendrá una función setDatos( ) y otra función getDatos( ). Escribir un POO que lea por teclado un arreglo de instancias de la clase derivada, implementar un método para actualizar la categoría del programador y después visualizar el vector.

  10.  Escribir un POO  para definir la clase Circulo y la clase Rectangulo, y crear una clase derivada Cilindro. Leer por teclado un arreglo de instancias de la clase heredada, implementar un método para calcular el volumen, y después visualizar el vector. (V = ת.r².h )

____________________________________________

 Construcción de Interfaces Gráficas

____________________________________________

 http://appframework.dev.java.net


// Este programa permite definir la configuración básica de una ventana
import java.awt.*;
import javax.swing.*;

/**
*
* @author Viejo Gus
*/
public class InterfazVentana extends JFrame{
   public InterfazVentana(){
   setTitle("Vehículos PengüinCar");
   setSize(290,300);
   setResizable(false);
   setVisible(true);
   setDefaultCloseOperation(EXIT_ON_CLOSE);
   }
   public static void main(String[] args){
       new InterfazVentana();
   }
}
-----------------------------------------------

// Otro programa ejemplo utilizando la clase JFrame
// MenuPpal.java
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MenuPpal extends JFrame{

private JLabel etiqueta1;

private JButton clientes,ventas,salir,proveedores;

public MenuPpal(){

super("MENÚ PRINCIPAL");

Container g= getContentPane();

g.setLayout(new BorderLayout(10,10));

Eventos cont=new Eventos();

Icon Pingui=new ImageIcon("penguin.jpg");
  // Para descargar la imagen:   penguin.jpg

etiqueta1=new JLabel();
etiqueta1.setText("PenguinSoft");
etiqueta1.setIcon(Pingui);
etiqueta1.setHorizontalTextPosition(SwingConstants.CENTER);
etiqueta1.setVerticalTextPosition(SwingConstants.TOP);
g.add(etiqueta1,BorderLayout.CENTER);

clientes=new JButton("Clientes");
ventas=new JButton("Ventas");
proveedores=new JButton("Proveedores");
salir=new JButton("Salir");

clientes.addActionListener(cont);
g.add(clientes,BorderLayout.WEST);
ventas.addActionListener(cont);
g.add(ventas,BorderLayout.EAST);
proveedores.addActionListener(cont);
g.add(proveedores,BorderLayout.NORTH);
salir.addActionListener(cont);
g.add(salir,BorderLayout.SOUTH);

setSize(260,250);
setLocation(225,200);
show();
}

private class Eventos implements ActionListener{
public void actionPerformed(ActionEvent e)
{

if(e.getSource()==salir){
JOptionPane.showMessageDialog(null,"Hasta Pronto, 'mis pupilos'!");
System.exit(0);
}
else if(e.getSource()==clientes){
}
else if(e.getSource()==proveedores){
}
else if(e.getSource()==ventas){
}
}

}
public static void main(String args[]){

MenuPpal a=new MenuPpal();
}

}

----------------------------------------
// Creación de un botón
import java.awt.*;

public class Boton extends Frame {
   Button button = new Button("Buenos dias");
   Boton(){
   super("Mi saludo");
   add(button, BorderLayout.CENTER);
   pack();
   setVisible(true);
   }
   public static void main(String[] args){
      new Boton();
   }
}

---------------------------------------

 Creación de Paneles:

package poo_java;

import java.awt.*;
import javax.swing.*;
import javax.swing.border.TitledBorder;

class PanelVehiculo extends JPanel{
   public PanelVehiculo(){
     setLayout(new GridLayout(5,2));
     setPreferredSize(new Dimension(0,130));
     TitledBorder border = BorderFactory.createTitledBorder( "Datos del Vehiculo" );
     border.setTitleColor(Color.BLUE);
     setBorder(border);
   }
}
class PanelDescuentos extends JPanel{
   public PanelDescuentos(){
   setLayout(new GridLayout(2,2));
   TitledBorder border = BorderFactory.createTitledBorder( "Descuentos" );
   border.setTitleColor(Color.BLUE);
   setBorder(border);
   }
}
class PanelResultados extends JPanel{
   public PanelResultados(){
   setLayout(new GridLayout(2,3));
   setPreferredSize(new Dimension(0,65));
   TitledBorder border = BorderFactory.createTitledBorder( "Resultados" );
   border.setTitleColor(Color.BLUE);
   setBorder(border);
   }
}

public class InterfazPanel extends JFrame {
   private PanelVehiculo panelVehiculo;
   private PanelDescuentos panelDescuentos;
   private PanelResultados panelResultados;
   public InterfazPanel(){
     setTitle("Venta de vehiculos");
     setDefaultCloseOperation(EXIT_ON_CLOSE);
     setLayout(new BorderLayout());
     panelVehiculo = new PanelVehiculo();
     add(panelVehiculo, BorderLayout.NORTH);
     panelDescuentos = new PanelDescuentos();
     add(panelDescuentos, BorderLayout.CENTER);
     panelResultados = new PanelResultados();
     add(panelResultados, BorderLayout.SOUTH);
     setSize(290,300);
     setResizable(false);
     setVisible(true);
     pack();
   }
public static void main(String[] args){
   new InterfazPanel();
   }
}

____________________________________________

//package poo_java;
import java.awt.*;
import javax.swing.*;
import javax.swing.border.TitledBorder;
/**
*
* @author Viejo Gus
*/
class PanelVehiculo extends JPanel{
private JTextField txtMarca;
private JTextField txtLinea;
private JTextField txtModelo;
private JTextField txtValor;
private JLabel labMarca;
private JLabel labLinea;
private JLabel labModelo;
private JLabel labValor;
public PanelVehiculo(){
setLayout(new GridLayout(5,2));
setPreferredSize(new Dimension(0,130));
TitledBorder border = BorderFactory.createTitledBorder( "Datos del Vehiculo" );
border.setTitleColor(Color.BLUE);
setBorder(border);
labMarca = new JLabel( "Marca ");
labLinea = new JLabel( "Linea ");
labModelo = new JLabel( "Modelo ");
labValor = new JLabel( "Valor ");
txtLinea = new JTextField();
txtModelo = new JTextField();
txtValor = new JTextField();
txtValor = new JTextField( "$ 0");

txtMarca = new JTextField();
txtValor.setForeground(Color.BLUE);
txtValor.setBackground(Color.WHITE);
add( labMarca );
add( txtMarca );
add( labLinea );
add( txtLinea );
add( labModelo );
add( txtModelo );
add( labValor );
add( txtValor );
txtValor.setEditable(true);
}
}
class PanelDescuentos extends JPanel{
public PanelDescuentos(){
setLayout(new GridLayout(2,2));
TitledBorder border = BorderFactory.createTitledBorder( "Descuentos" );
border.setTitleColor(Color.BLUE);
setBorder(border);
}
}
class PanelResultados extends JPanel{
public PanelResultados(){
setLayout(new GridLayout(2,3));
setPreferredSize(new Dimension(0,65));
TitledBorder border = BorderFactory.createTitledBorder( "Resultados" );
border.setTitleColor(Color.BLUE);
setBorder(border);
}
}

public class InterfazVehiculos extends JFrame {
private PanelVehiculo panelVehiculo;
private PanelDescuentos panelDescuentos;
private PanelResultados panelResultados;
public InterfazVehiculos(){
setTitle("PenguinCar");
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(new BorderLayout());
panelVehiculo = new PanelVehiculo();
add(panelVehiculo, BorderLayout.NORTH);
panelDescuentos = new PanelDescuentos();
add(panelDescuentos, BorderLayout.CENTER);
panelResultados = new PanelResultados();
add(panelResultados, BorderLayout.SOUTH);
setSize(490,500);
setResizable(false);
setVisible(true);
pack();
}
public static void main(String[] args){
new InterfazVehiculos();
}
}
// Taller: Implementar el panel de Descuentos e insertar dos botones en el panel de Resultados

---------------------------------------

 Creación de Threads o Hilos:

// Ejemplo de Threads o Hilos
// Se definen unos sencillos hilos. Se detendrán un rato
// antes de imprimir sus nombres y retardos

class PruebaH extends Thread {
private String nombre;
private int retardo;

// Constructor para almacenar el nombre y el retardo
public PruebaH( String s,int d ) {
nombre = s;
retardo = d;
}

// El metodo run() es similar al main(), pero para
// threads. Cuando run() termina el thread muere
public void run() {
// Se retrasa la ejecución el tiempo especificado
try {
sleep( retardo );
} catch( InterruptedException e ) {
;
}

// Ahora se imprime el nombre
System.out.println( "Hola, mis pupilos! "+nombre+" "+retardo );
}
}

public class MultiHola {
public static void main( String args[] ) {
PruebaH h1,h2,h3;

// Se crean los hilos o threads
h1 = new PruebaH( "Hilo 1",(int)(Math.random()*2000) );
h2 = new PruebaH( "Hilo 2",(int)(Math.random()*2000) );
h3 = new PruebaH( "Hilo 3",(int)(Math.random()*2000) );

// Se arrancan los hilos
h1.start();
h2.start();
h3.start();
}
}

 


 

Inicio | Biografía | Cursos | Para pensar... | Para reflexionar... | Para reir | Enlaces

 
Profesor Gustavo Martínez Villalobos
Email: gustavo.martinez@unibague.edu.co
Facultad de Ingeniería de Sistemas, Coruniversitaria
Ibagué, Tolima, COLOMBIA