1

TALLER DE PROGRAMACIÓN III

INGENIERÍA DE SISTEMAS

UNIVERSIDAD DE NARIÑO

ABSTRACCIÓN

La abstracción es la supresión intencionada (u ocultación) de algunos detalles de un proceso o artefacto, con el

fin de destacar más claramente otros aspectos, detalles o estructuras. Se trata de una técnica que las personas
utilizan diariamente para crear, comprender o manejar sistemas complejos. La abstracción se puede realizar a
diferentes niveles, dependiendo de qué aspectos del sistema se desea enfatizar. En cada nivel de abstracción
cierta información se muestra y cierta información se omite. No hay modo de representar todos los detalles
cuando un artefacto se muestra a un mayor nivel de abstracción. Incluso si todos los detalles pudiesen ser
descritos, nadie podría asimilar o procesar tanta información. Tomemos, por ejemplo, las escalas en los mapas
de información geográfica. En un mapamundi únicamente se muestran las características más importantes de
la superficie terrestre, como cadenas montañosas, corrientes oceánicas u otras estructuras de tamaño similar.
Sin embargo, características de menor tamaño, como pueblos o carreteras no aparecerán. Un mapa que cubra
una región del planeta menor, como por ejemplo un continente, podría incluir las fronteras y las grandes
ciudades. Un mapa de un único país incluiría ciudades más pequeñas, los nombres de ciertas montañas o las
carreteras principales. En el caso de un mapa de una gran ciudad encontraríamos las principales avenidas y
calles y los edificios o parques más importantes.

Como vemos, en cada nivel de abstracción se muestra cierta información mientras otra permanece
deliberadamente oculta. Esto puede incluso depender de quién vaya a utilizar el objeto o sistema. El
conocimiento que un ciudadano medio posee sobre los autos (su abstracción) incluye como se manejan y para
que sirven, pero su conocimiento de cómo funciona un auto se reduce, en general, a la de un dispositivo
compuesto por un motor que conectado a los mandos del vehículo, y en caso de disponer del combustible
apropiado, produce un movimiento giratorio que se transmite a las ruedas del coche a través de una caja de
cambios y un sistema de transmisión, lo cual permite al vehículo desplazarse a conveniencia del conductor.
Aunque, evidentemente esta descripción no es del todo exacta, es lo suficientemente aproximada para poder
utilizar el vehículo en la vida diaria. Mediante la abstracción creamos modelos de la realidad, evitando la
necesidad de conocer todos los detalles, y enfocando nuestra atención en determinadas características clave.
A menudo se describe este proceso como ocultación de la información. Es una técnica que se aplica a todos los
ámbitos, no sólo a la Informática.

PROGRAMACIÓN ORIENTADA A OBJETOS

La Programación Orientada a Objetos (POO) es una forma especial de programar, más cercana a como
expresaríamos las cosas en la vida real, que otros tipos de programación. Durante años, los programadores se
 2

han dedicado a construir aplicaciones muy parecidas que resolvían una y otra vez los mismos problemas. Para
conseguir que los esfuerzos de los programadores puedan ser reutilizados por otras personas se creó la POO, la
cual usa una serie de normas y estándares para cumplir este objetivo.

POO no es difícil, pero es una manera especial de pensar, a veces subjetiva de quien la programa, de manera
que la forma de hacer las cosas puede ser diferente entre uno u otro programador, aunque podamos hacer los
programas de formas distintas, no todas ellas son correctas, lo difícil no es programar orientado a objetos sino
programar bien. Programar bien es importante, porque así podemos aprovechar de todas las ventajas de la POO.
Con la POO tenemos que aprender a pensar las cosas de una manera distinta, para escribir nuestros programas
en términos de objetos, propiedades y métodos.

CLASES Y OBJETOS

El mundo está lleno de objetos: el coche, la lavadora, la mesa, el teléfono, etc. El paradigma de programación
orientada a objetos proporciona las abstracciones necesarias para poder desarrollar sistemas software de una
forma más cercana a esta percepción del mundo real.

Mediante la POO, a la hora de tratar un problema, podemos descomponerlo en subgrupos de partes relacionadas.
Estos subgrupos pueden traducirse en unidades autocontenidas llamadas objetos. Antes de la creación de un
objeto, se debe definir en primer lugar su formato general, su plantilla, que recibe el nombre de clase. Por
ejemplo, pensemos que estamos intentando construir una aplicación de dibujo de cuadrados. Nuestro programa
va a ser capaz de pintar cuadrados con diferentes tamaños y colores: uno será rojo y de 3 centímetros de lado,
otro verde y de 5 centímetros de lado, etc. Como podemos deducir, cada cuadrado está definido por dos
características, lado y color, y contiene la operación dibuja. Desde el punto de vista de la POO, cada cuadrado
se va a representar como un objeto de la clase Cuadrado que es la contiene las características y operaciones
comunes de los objetos. En realidad, estamos creando un nuevo tipo, el tipo Cuadrado, y cada variable de este
tipo especial recibe el nombre de objeto.

Una clase, por lo tanto, puede definirse como un tipo de datos cuyas variables son objetos o instancias de una
clase. Puede decirse que el concepto de clase es estático y el concepto de objeto es dinámico; ya que, sólo
existe en tiempo de ejecución. Cada objeto de una clase comparte con el resto las operaciones, y a la vez posee
sus propios valores para los atributos que posee: esto es, su estado. Las operaciones, también llamadas
mensajes, se usarán tanto para cambiar el estado de un objeto como para comunicar objetos entre sí mediante
el paso de mensajes.

La clase es una plantilla o patrón a partir de la cual se crean muchos otros objetos similares, también se podría
definir a una clase como la agrupación de objetos que poseen características comunes.

Es decir, cuando se escribe un programa de computación en un lenguaje orientado a objetos está creando en
su computador un modelo de alguna parte del mundo real. Las partes con que se construye el modelo provienen
 3

de los objetos que aparecen en el dominio del problema. Estos objetos deben estar representados en el modelo
computacional que se está creando.

Por ejemplo, se desea trabajar una simulación de tráfico. Un tipo de entidad con la que tendrá que trabajar es
autos. ¿Qué es un auto en nuestro contexto? ¿Es una clase o es un objeto? Algunas preguntas nos ayudarán a
tomar una decisión.

¿De qué color es un auto? ¿Cuán rápido puede marchar? ¿Dónde está en este momento?

Se observa que no podemos responder estas preguntas a menos que hablemos de un auto específico. La razón
es que, en este contexto, la palabra “auto” se refiere a la clase auto puesto que estamos hablando de los autos
en general y no de uno en particular.

Si digo, “Mi viejo auto se encuentra estacionado en el garaje de la casa”, podemos responder todas las preguntas
anteriores: este auto es rojo, no marcha demasiado rápido y está en mi garaje. Ahora estamos hablando de un
objeto, un ejemplo particular de un auto.

Generalmente, cuando nos referimos a un objeto en particular hablamos de una instancia. Es decir los objetos
son instancias de una clase en particular.

Cada clase contiene propiedades o atributos que son las características descriptivas de una clase. Cuando se
define una propiedad se especifica su nombre y su tipo de dato.

Por ejemplo en la Clase Alumno se pueden identificar los siguientes atributos

Apellidos de tipo String

Nombres de tipo String
Edad de tipo int
Estatura de tipo double
Las clases también poseen métodos que son los servicios que se le incluyen a la clase. Dentro de los métodos
se programan todas las funcionalidades que debe ofrecer la clase.

La sintaxis de la clase debe ser la siguiente:

 4

public class MiClase{

//Definición de atributos
//Definición de métodos
}
public class Lavadora {

//atributos
private String marca;

private String capacidad;

//métodos
public Lavadora(String m, String c){
marca=m; Método Constructor
capacidad=c;
}

public void lavar(){

System.out.println("Estoy lavando");
}
public void secar(){
System.out.println("Estoy secando su ropa");
}
public String decirMarca(){
return marca;
}
public void cambiarMarca(String m){
marca=m;
}
}

¿QUE ES UN OBJETO?

Al inspeccionar objetos diferentes observará que todos los objetos de la misma clase tienen los mismos campos;
es decir que el número, el tipo de dato y los nombres de los campos de una misma clase son los mismos, mientras
que el valor de un campo en particular de cada objeto puede ser distinto. Por el contrario, los objetos de clases
diferentes pueden tener diferentes campos.

La razón es que el número, el tipo de dato y el nombre de los campos o atributos se definen en una clase, no
en un objeto. Por ejemplo cuando se crea un objeto de la clase Lavadora tendrá automáticamente los atributos
y los métodos definidos dentro de la clase.

LOS MÉTODOS

Los métodos en Java siempre son miembros de clases, no hay métodos o funciones fuera de ellas; su
implementación se incluye dentro del cuerpo de la clase.

Los métodos se pueden clasificar en cuatro tipos que son los siguientes:
 5

Constructores. Un constructor es el primer método que se ejecuta al realizar la instancia de un objeto. Uno de
los usos principales de un constructor es la inicialización de los atributos de la clase. El método constructor
debe tener visibilidad pública y no posee retorno.

Consultores: Un consultor es el método que permite retornar el valor de un atributo con visibilidad private al
aplicar el concepto de encapsulamiento.

Modificadores: Un modificador es el método que permite asignar a un atributo con visibilidad private al aplicar
el concepto de encapsulamiento.

Analizadores: Un analizador es el método que permite implementar la lógica del servicio del mismo, es decir,
allí se implementan los algoritmos requeridos.

Ejemplo: Definición de una clase llamada Punto que contiene coordenadas x-y de un punto en un plano.

public class Punto {

private int x; // coordenada x

private int y; // coordenada y

public Punto(int x1, int y1) {// constructor

x = x1;
y = y1;
}
public Punto() { // constructor sin argumentos
x = y = 0;
}
public int leerX() { // devuelve el valor de x
return x;
}
public int leerY() { // devuelve el valor de y
return y;
}
void fijarX(int valorX) { // establece el valor de x

x = valorX;
}
void fijarY(int valorY) { // establece el valor de y

y = valorY;
}
}
Ejercicio: Crear una clase llamada Cuenta, la cual mantiene el saldo de una cuenta bancaria. Un banco ordinario
da servicio a muchas cuentas, cada una con su propio saldo, por lo que la clase debe declarar una variable de
instancia, de tipo double, llamada saldo. La clase Cuenta debe contener un constructor y tres métodos.

El método abonar no debe devolver datos cuando completa su tarea, por lo que su tipo de valor de retorno es
void. El método recibirá un parámetro llamado monto: un valor double que se sumará al saldo.

El método retirar debe devolver datos cuando completa su tarea, por lo que su tipo de valor de retorno es
double. El método recibirá un parámetro llamado monto: un valor double que se restará al saldo. El retiro se
puede hacer si el valor del saldo actual es igual o mayor al valor enviado. Si se puede realizar el retiro se retorna
el valor retirado de lo contrario se retorna cero.
 6

El método obtenerSaldo permitirá obtener el valor del saldo de un objeto Cuenta específico. El método
especifica el tipo de valor de retorno double y una lista de parámetros vacía.

Ejercicio: Crear una clase llamada Racional que permite crear un número racional (numerador y denominador).
Debe tener un constructor con parámetros (si el denominador enviado es 0 se debe asignar 1 al denominador).
Métodos consultores y modificadores para cada atributo. Un método que retorne una cadena indicando si el
número es propio o impropio. Un método que retorne una cadena que convierta la fracción en un número mixto
cuando sea posible.
 7

La codificación interna de una clase es el lugar en el que se definen los campos, los constructores y los métodos
que dan a los objetos de la clase sus características particulares y su comportamiento. Podemos resumir las
características esenciales de estos tres componentes de una clase como sigue:

• Los campos almacenan datos para que cada objeto los use.
• Los constructores permiten que cada objeto se prepare adecuadamente cuando es creado
• Los métodos implementan el comportamiento de los objetos.

En Java existen muy pocas reglas sobre el orden que se puede elegir para definir los campos, los constructores
y os métodos dentro de una clase, pero es recomendable listar primero los campos, segundo los constructores
y por último los métodos.

public class NombreDeClase{

campos o atributos
constructores
métodos
}
Los campos son espacios dentro de un objeto que se usan para almacenar valores. Todo objeto una vez creado,
dispondrá de un espacio para cada campo declarado en su clase.

Los constructores de una clase tienen un rol especial que cumplir: su responsabilidad es poner cada objeto de
esa clase en un estado adecuado para que pueda ser usado una vez que haya sido creado. Esta operación se
denomina inicialización o instanciación.

La manera en que los constructores y los métodos reciben valores, es mediante sus parámetros. Los parámetros
se definen en el encabezado o signatura del método. Los parámetros están disponibles sólo dentro del cuerpo
del constructor o del método que lo declara, es decir, su alcance es local. En cambio, el alcance de un atributo
o campo es de toda la clase (alcance global) y puede ser accedido desde cualquier lugar en la misma clase.

Ejemplo: Crear una clase que registre información sobre un libro. Tendrá como atributos e tipo String el autor
y el título del libro.

La clase debe tener un constructor con parámetros y los métodos que se indicarán a continuación:

public class Libro{

private String aut;
private String tit;

public Libro(String autL, String titL){

aut = autL;
tit = titL;
}
}
 8

• Agregar al esquema de la clase Libro dos métodos: imprimirAutor e imprimirTitulo, que impriman
respectivamente los campos del autor y del título.
• Agregar un campo más, páginas, a la clase Libro para almacenar la cantidad de páginas. Este campo
debe ser de tipo int y su valor inicial debe ser pasado al único constructor, junto con las cadenas para
el autor y el título. Adicionar también un método consultor que retorne el número de páginas registrado.
• Agregar el método imprimirDetalles que muestra en pantalla el autor, el título y la cantidad de páginas.
• Agregar otro campo a la clase, numero de referencia. Este campo puede almacenar, un número de
referencia para una biblioteca. Debe ser de tipo String y ser inicializado en el constructor con una
cadena vacía. Definir un método modificador para este campo con la siguiente signatura:

public void setNumRef(String ref)

• Modificar el método imprimirDetalles para que incluya la impresión del número de referencia

Ejemplo: Definir una clase DiaAnyo que contenga los atributos mes y día, los métodos igual() y visualizar(). Que
el mes se registre como un valor entero: 1, Enero; 2, Febrero y así sucesivamente; el día del mes debe registrarse
en la variable entera día. Escribir un programa que compruebe si una fecha es su cumpleaños. El método main()
de la clase principal, Cumple, crea un objeto DiaAnyo y llama al método igual() para determinar si la fecha del
objeto coincide con la fecha de su cumpleaños, que se ha leído del dispositivo de entrada.

public class DiaAnyo{

private int mes;
private int dia;
public DiaAnyo(int d, int m) {
dia = d;
mes = m;
}

public boolean igual(DiaAnyo d) {

if ((dia == d.dia) && (mes == d.mes))
return true;
else
return false;
}

public void visualizar() {

System.out.println("mes = " + mes + " , dia = " + dia);
}
}
 9

/////////////////////////////////////////

import java.io.*;
import java.util.*;
public class Cumple
{
public static void main(String[] ar)throws IOException {
DiaAnyo hoy;
DiaAnyo cumpleanyos;
int d, m;
Scanner entrada = new Scanner((System.in));
System.out.print("Introduzca fecha de hoy, dia: ");
d = entrada.nextInt();
System.out.print("Introduzca el número de mes: ");
m = entrada.nextInt();
hoy = new DiaAnyo(d,m);
System.out.print("Introduzca su fecha de nacimiento, dia: ");
d = entrada.nextInt();
System.out.print("Introduzca el número de mes: ");
m = entrada.nextInt();
cumpleanyos = new DiaAnyo(d,m);
System.out.print( " La fecha de hoy es ");
hoy.visualizar();
System.out.print( " Su fecha de nacimiento es ");
cumpleanyos.visualizar();
if (hoy.igual(cumpleanyos))
System.out.println( "¡Feliz cumpleaños ! ");
else
System.out.println( "¡Feliz dia ! ");
}
}
 10

MODIFICADORES DE ACCESO

La encapsulación es un mecanismo que consiste en declarar los atributos y métodos de una clase con niveles de
acceso. Por lo tanto, la encapsulación garantiza la integridad de los datos que contiene un objeto. Los
modificadores de acceso son parte del encapsulamiento de datos que consiste en hacer visible los datos de los
atributos y procesos internos que ocurren en las operaciones que realmente sean necesarios, controlando el
acceso a los datos que conforman un objeto.

Para definir un modificador de acceso en los atributos y métodos se utilizan las siguientes palabras reservadas:

• public: se puede acceder desde cualquier clase. En UML el modificador public se representa con el
carácter más ‘+’
• private: solo se puede acceder dentro de la clase. En UML se representa con el carácter menos ‘-‘
• protected: se puede acceder desde una relación jerárquica de herencia entre padres e hijos. En UML
se representa con el carácter ‘#’

Se recomienda que los atributos de una clase se declaren privados para dar un nivel de seguridad, restringiendo
su acceso para evitar el mal uso de sus datos. Al declarar atributos privados se debe programar los métodos
getter (consultores) y setter (modificadores) para cada atributo privado.

A continuación se muestran algunas reglas de convención para generar los métodos getter y setter:

public class Circulo {

//miembros privados
private double x, y; //coordenadas del centro
//miembros públicos
public double r; //radio del círculo

private void msgNegativo() {

System.out.println("El radio es negativo. Se convierte a positivo");
}
 11

//miembros públicos
public Circulo() { //constructor sin parámetros
x = 0;
y = 0;
r = 1;
}

public Circulo(double cx, double cy, double cr) {

x = cx;
y = cy;
if (cr < 0) {
msgNegativo();
cr = -cr;
}
r = cr;
}
public double longitud() {
return 2 * Math.PI * getR();
}
public double area() {
return Math.PI * getR() * getR();
}
public double getX() {
return x;
}
public void setX(double x1) {
x = x1;
}
public double getY() {
return y;
}
public void setY(double y1) {
y = y1;
}
public double getR() {
return r;
}
public void setR(double r1) {
r = r1;
}
}
 12

=================================================================
import java.util.Scanner;

public class PruebaCirculo {

public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
System.out.println("Ingrese coordenada en x");
double x = entrada.nextDouble(); // lee el primer valor double
System.out.println("Ingrese coordenada en y");
double y = entrada.nextDouble(); // lee el segundo valor double
System.out.println("Ingrese radio");
double r = entrada.nextDouble(); // lee el tercer valor double
Circulo cir = new Circulo(x, y, r);
//Si se quiere utilizar esta instrucción nos muestra error
//debido a que x es privado
// cir.x(10);
//para poder actualizar el valor de x se debe utilizar
//el método modificador correspondiente al atributo
cir.setX(10);
//Por el contrario como el atributo r es público
//se puede acceder a él directamente
cir.r = 20;
System.out.println("El circulo tiene coordenada X:"
+ cir.getX() + "coordenada Y: " + cir.getY() + "y radio" + cir.r);
System.out.printf("La longitud del círculo es %.3f \n", cir.longitud());
System.out.printf("El área del círculo es %.3f \n", cir.area());
Circulo cir1 = new Circulo(5, 10, -3);
}
}

SOBRECARGA DE MÉTODOS

Pueden declararse métodos con el mismo nombre en la misma clase, siempre y cuando tengan distintos
conjuntos de parámetros (determinados en base al número, tipos y orden de los parámetros). A esto se le conoce
como sobrecarga de métodos. Cuando se hace una llamada a un método sobrecargado, el compilador de Java
selecciona el método apropiado mediante un análisis del número, tipos y orden de los argumentos en la llamada.
Por lo general, la sobrecarga de métodos se utiliza para crear varios métodos con el mismo nombre que realicen
la misma tarea o tareas similares, pero con distintos tipos o distintos números de argumentos.

La sobrecarga de métodos es una de las formas en que Java implementa el polimorfismo. La palabra
Polimorfismo significa “la facultad de asumir muchas formas”, refiriéndose a la facultad de llamar a muchos
métodos diferentes utilizando una única sentencia. Esta característica permite implementar múltiples formas
de un mismo método.
 13

public class Sobrecarga {

public int cuadrado(int Valor)
{
return Valor*Valor;
}
public double cuadrado(double Valor)
{
return Valor*Valor;
}
}

public class ManejoSobreCarga extends javax.swing.JFrame {

Sobrecarga prueba;
public ManejoSobreCarga() {
prueba=new SobrecargaMetodos();
initComponents();
}

private void cmbCalActionPerformed(java.awt.event.ActionEvent evt) {

int c1=prueba.cuadrado(Integer.parseInt(txtEnt.getText()));
lblEnt.setText(c1+"");
double c2=prueba.cuadrado(Double.parseDouble(txtDou.getText()));
lblDou.setText(c2+"");
}

CÓMO SE DIFERENCIAN LOS MÉTODOS SOBRECARGADOS ENTRE SÍ

El compilador diferencia los métodos sobrecargados en base a su firma o signatura: una combinación del nombre
del método y del número, tipos y orden de sus parámetros. Si el compilador solo se fijara en los nombres de los
métodos durante la compilación, el código anterior seria ambiguo; el compilador no sabría cómo distinguir entre
los dos métodos cuadrado. De manera interna, el compilador utiliza nombres de métodos más largos que
incluyen el nombre del método original, el tipo de cada parámetro y el orden exacto de los parámetros para
determinar si los métodos en una clase son únicos en esa clase.

Por ejemplo, el compilador podría utilizar el nombre lógico “cuadrado de int” para el método cuadrado que
especifica un parámetro int, y el método “cuadrado de double” para el método cuadrado que especifica un
parámetro double (los nombres reales que utiliza el compilador son más complicados).

Si la declaración de metodo1 empieza así:

void metodo1( int a, float b )

 14

entonces el compilador podría usar el nombre lógico “ metodo1 de int y float ”. Si los parámetros se
especificaran así:

void metodo1( float a, int b )

entonces el compilador podría usar el nombre lógico “metodo1 de float e int”. Observe que el orden de los
tipos de los parámetros es importante; el compilador considera que los dos encabezados anteriores de metodo1
son distintos.

Ejemplo: Diseñaremos una clase que almacene una fecha, verificando que es correcta, esto es, que el día esté
entre los límites 1 y días del mes, que el mes esté entre los límites 1 y 12 y que el año sea mayor o igual que
1582, además sobrecargaremos el método constructor de la clase Fecha para que pueda ser invocado con cero
argumentos; con un argumento el día; con dos argumentos, el día y el mes; y con tres argumentos, el día, el
mes y el año. Los datos día, mes o año omitidos en cualquiera de los casos, serán obtenidos de la fecha actual
proporcionada por el sistema.

import java.util.Calendar;
import java.util.GregorianCalendar;
import javax.swing.*;
public class Fecha {
//atributos
private int dia, mes, año;

public void asignarFecha() {

//Asignar por omisión la fecha actual
GregorianCalendar fechaActual = new GregorianCalendar();
dia = fechaActual.get(Calendar.DAY_OF_MONTH);
mes = fechaActual.get(Calendar.MONTH) + 1;
año = fechaActual.get(Calendar.YEAR);
}
public Fecha() {
//Asignar por omisión la fecha actual
asignarFecha();
}
public Fecha(int dd) {
GregorianCalendar fechaActual = new GregorianCalendar();
dia = dd;
mes = fechaActual.get(Calendar.MONTH) + 1;
año = fechaActual.get(Calendar.YEAR);
if (!fechaCorrecta()) {
JOptionPane.showMessageDialog(null,"Sobre Carga de Métodos",
"Fecha Incorrecta. Se asigna la actual",JOptionPane.ERROR);
asignarFecha();
}
}
 15

public Fecha(int dd, int mm) {

GregorianCalendar fechaActual = new GregorianCalendar();
dia = dd; mes = mm;
año = fechaActual.get(Calendar.YEAR);
if (!fechaCorrecta()) {
JOptionPane.showMessageDialog(null,"Sobre Carga de Métodos",
"Fecha Incorrecta. Se asigna la actual",JOptionPane.ERROR);
asignarFecha();
}
}
public Fecha(int dd, int mm, int aaaa) {
dia = dd; mes = mm;
año = aaaa;
if (!fechaCorrecta()) {
JOptionPane.showMessageDialog(null,"Sobre Carga de Métodos",
"Fecha Incorrecta. Se asigna la actual",JOptionPane.ERROR);
asignarFecha();
}
}
public boolean bisiesto() {
return ((año % 4 == 0) && (año % 100 != 0) || (año % 400 == 0));
}
public boolean fechaCorrecta() {
boolean diaC, mesC, añoC;
//año correcto?
añoC = (año >= 1582);
//mes correcto?
mesC = (mes >= 1) && (mes <= 12);
switch (mes) { //dia correcto?
case 2:
if (bisiesto())
diaC = (dia >= 1 && dia <= 29);
else
diaC = (dia >= 1 && dia <= 28);
break;
case 4:
case 6:
case 9:
case 11:
diaC = (dia >= 1 && dia <= 30);
break;
default:
diaC = (dia >= 1 && dia <= 31);
}
return diaC && mesC && añoC;
}
 16

public String escribir() {

return (dia + "/" + mes + "/" + año);
}
}
 17

///////////////////////////////////////////////////////////////////////////////////

import javax.swing.*;

public class Arbol {

int altura;

public Arbol() {
visualizar("Plantando un retoño");
altura = 0;
}

public Arbol(int i) {
visualizar("Creando un nuevo arbol que tiene " + i + " metros de alto");
altura = i;
}

void info() {
visualizar("El arbol tiene " + altura + " metros de alto");
}

void info(String S) {
visualizar(S + ": El arbol tiene " + altura + " metros de alto");
}

public void visualizar(String S) {

JOptionPane.showMessageDialog(null,S,"SobreCarga",JOptionPane.INFORMATION_MESSAGE);
}
}

Se puede crear un objeto Arbol, bien como un retoño, sin argumentos,

o como una planta que crece en un criadero, con una altura ya
existente. Para dar soporte a esto, hay dos constructores, uno que no
toma argumentos (a los constructores sin argumentos se les llama
constructores por defecto), y uno que toma la altura existente.

Se puede también invocar al método info( ) de más de una manera.

Por ejemplo, con un parámetro String si se tiene un mensaje extra para
imprimir, y sin él si no se tiene nada más que decir.
 18

Crear una clase que permita manejar las horas, minutos y segundos que representa la hora actual del día.

Crear una clase que maneje la hora actual y que tenga 4 constructores, el primero sin parámetros y que obtenga
la hora actual, el segundo recibe como parámetro el valor de la hora, el tercero recibe la hora y minutos y el
último constructor recibe hora, minutos y segundos. Se debe crear un método que retorne una cadena con la
hora en formato estándar (am o pm).

Para obtener la hora actual se utilizan funciones de la clase Gregorian Calendar

hora =calendario.get(Calendar.HOUR_OF_DAY);

minutos = calendario.get(Calendar.MINUTE);

segundos = calendario.get(Calendar.SECOND);
 19

HERENCIA

La herencia es el mecanismo de implementación mediante el cual elementos más específicos incorporan la

estructura y comportamiento de elementos más generales.

Gracias a la herencia es posible especializar o extender la funcionalidad de una clase, derivando de ella nuevas
clases. Es decir, la herencia es el proceso mediante el cual una clase adquiere las propiedades (atributos) y
comportamiento (métodos) de otra.

La herencia es siempre transitiva: una clase puede heredar características de superclases que se encuentran
muchos niveles más arriba en la jerarquía de herencia. Ejemplo: si la clase Perro es una subclase de la clase
Mamífero, y la clase Mamífero es una subclase de la clase Animal, entonces el Perro heredará atributos tanto
de Mamífero como de Animal.

La clase A se debe relacionar mediante herencia con la clase B si “A ES-UN B”. Si la frase suena bien, entonces
la situación de herencia es la más probable para ese caso, por ejemplo

• Un pájaro es un animal
• Un gato es un mamífero
• Un pastel de manzana es un pastel
• Una matriz de enteros es un matriz
• Un coche es un vehículo

Sin embargo, si la frase suena rara por una razón u otra, es muy probable que la relación de herencia no sea lo
más adecuado. Por ejemplo:
• Un pájaro es un mamífero
• Un pastel de manzana es una manzana
• Una matriz de enteros es un entero
• Un motor es un vehículo

JERARQUIZACIÓN

Es un proceso por el cual se crean organizaciones de elementos en distintos niveles. No es un concepto

específicamente de POO, sino que es algo que se ve en la vida real en muchos ámbitos, algo inherente a
cualquier tipo de sistema. Puedo tener diversos tipos de jerarquías, como clasificación o composición.

Composición

Se presenta cuando unos elementos están compuestos de otros, o que unos elementos están presentes en otros.
Por ejemplo, el sistema respiratorio y los pulmones, la nariz, etc. Podemos decir que los pulmones están dentro
del sistema respiratorio, así como dentro de los pulmones encontramos bronquios y alvéolos. En esta jerarquía
de elementos tenemos composición porque donde unos forman parte de otros. En una factura también podemos
decir que puede haber una jerarquía de composición. La factura tiene un cliente, varios conceptos facturables,
un impuesto, etc.
 20

Clasificación:

Este tipo de jerarquización indica que unos elementos son una especialización de otros. Por ejemplo, los
animales, donde tenemos vertebrados e invertebrados. Luego, dentro de los vertebrados encontramos aves,
reptiles, mamíferos, etc. En los mamíferos encontramos perros, vacas, conejos.

Los lenguajes de programación orientados a objetos son capaces de crear jerarquizaciones basadas en
composición con lo que ya sabemos de clases y objetos. Eso es porque podemos tener como propiedades de
objetos, otros objetos. Por ejemplo, en el caso de la factura, podríamos tener como propiedades el cliente, el
impuesto, la lista de conceptos facturables, etc. Para hacer jerarquías de clasificación hace falta conocer la
herencia.

Es necesario hacer una diferencia entre la relación “es un” y la relación “tiene un”. La relación “es un”
representa a la herencia. En este tipo de relación, un objeto de una subclase puede tratarse también como un
objeto de su superclase. Por ejemplo, un automóvil es un vehículo. En contraste, la relación “tiene un”
identifica a la composición. En este tipo de relación, un objeto contiene referencias a objetos como miembros.

Por ejemplo, un automóvil tiene un volante de dirección (y un objeto automóvil tiene una referencia a un objeto
volante de dirección
 21

Cuando una clase B se construye a partir de otra A mediante la herencia, la clase B hereda todos los atributos,
métodos y clases internas de la clase A. Además la clase B puede redefinir los componentes heredados y añadir
atributos, métodos y clases internas específicas.

Para indicar que la clase B (clase descendiente, derivada, hija o subclase) hereda de la clase A (clase
ascendiente, heredada, padre, base o superclase) se emplea la palabra reservada extends en la cabecera de la
declaración de la clase descendiente. La sintaxis es la siguiente:

public class ClaseB extends ClaseA {

// Declaracion de atributos y metodos especificos de ClaseB
// y/o redeclaracion de componentes heredados
}
¿Cuándo se aplica el mecanismo de herencia?

1. Cuando hay suficientes similitudes: Todas las características de la clase existente o la mayoría de ellas, son
adecuadas para la nueva clase.

2. En la nueva clase se ampliará y/o redefinirá el conjunto de características: La nueva clase definida a partir
de la clase existente, adopta todos los miembros de la clase existente: atributos y métodos

SUPERCLASES Y SUBCLASES

A menudo, un objeto de una clase “es un” objeto de otra clase también. Por ejemplo, en la geometría un
rectángulo es un cuadrilátero (al igual que los cuadrados, los paralelogramos y los trapezoides). Por lo tanto,
en Java puede decirse que la clase Rectangulo hereda de la clase Cuadrilatero. En este contexto, la clase
Cuadrilatero es una superclase, y la clase Rectangulo es una subclase. Un rectángulo es un tipo específico de
cuadrilátero, pero es incorrecto decir que todo cuadrilátero es un rectángulo; el cuadrilátero podría ser un
paralelogramo o alguna otra figura. Observe que las superclases tienden a ser “más generales”, y las subclases
“más específicas”.
 22

Como todo objeto de una subclase “es un” objeto de su superclase, y como una superclase puede tener muchas
subclases, el conjunto de objetos representados por una superclase generalmente es más grande que el conjunto
de objetos representado por cualquiera de sus subclases. Por ejemplo, la superclase Vehiculo representa a todos
los vehículos, incluyendo automóviles, camiones, barcos, bicicletas, etcétera. En contraste, la subclase Auto
representa a un subconjunto más pequeño y específico de los vehículos.

Las relaciones de herencia forman estructuras jerárquicas en forma de árbol. Una superclase existe en una
relación jerárquica con sus subclases. Cuando las clases participan en relaciones de herencia, se “afilian” con
otras clases. Una clase se convierte ya sea en una superclase, proporcionando miembros a otras clases, o en
una subclase, heredando sus miembros de otras clases. En algunos casos, una clase es tanto superclase como
subclase.

Ahora considere la jerarquía de herencia de Figura. Esta jerarquía empieza con la superclase Figura, la cual se
extiende mediante las subclases FiguraBidimensional y FiguraTridimensional; las Figuras son del tipo
FiguraBidimensional o FiguraTridimensional. El tercer nivel de esta jerarquía contiene algunos tipos más
específicos de figuras tipo FiguraBidimensional y FiguraTridimensional. Podemos seguir las flechas desde la
parte inferior del diagrama, hasta la superclase de más arriba en esta jerarquía de clases, para identificar varias
relaciones es un. Por ejemplo, un Triangulo es un objeto FiguraBidimensional y es una Figura, mientras que una
Esfera es una FiguraTridimensional y es una Figura.

El siguiente ejemplo muestra la forma como se realiza la implementación de clases con herencia. En este caso
los constructores de cada clase no contienen parámetros
public class Arte {
public Arte() {
System.out.println("Constructor de arte");
}
}

public class Dibujo extends Arte {

public Dibujo () {
System.out.println ("Constructor de dibujo");
}
}
 23

public class Animacion extends Dibujo {

public Animacion () {
System.out.println("Constructor de animacion");
}
}
public EjemploHerencia{
public static void main (String[] args) {
Animacion x = new Animacion();
}
}
La salida de este programa mostraría las llamadas automáticas a cada uno de los constructores
Constructor de arte
Constructor de dibujo
Constructor de animacion

La construcción del objeto x se da desde la base o clase hija y desde ésta se recorre la jerarquía hasta llegar a
la clase padre.

Cuando se desea invocar a un constructor de una clase padre que tiene parámetros hay que escribir
explícitamente la llamada al constructor de la clase padre usando la palabra clave super y la lista de parámetros
apropiada.

Por ejemplo supongamos que tenemos la clase de las personas.

public class Persona {
private String nombre;
private String direccion;
private int telefono;
public Persona(String nom, String dir, int f){
nombre = nom;
direccion = dir;
telefono = f;
}
// Con el constructor definimos el nombre, dirección y teléfono de la persona.
}

Al crear una clase, en vez de declarar miembros completamente nuevos, el programador puede designar que la
nueva clase herede los miembros de una clase existente. Esta clase existente se conoce como superclase o
padre, y la nueva clase se conoce como subclase o hija. Cada subclase puede convertirse en la superclase de
futuras subclases. Una subclase generalmente agrega sus propios campos y métodos. Por lo tanto, una subclase
es más específica que su superclase y representa a un grupo más especializado de objetos. Generalmente, la
subclase exhibe los comportamientos de su superclase junto con comportamientos adicionales específicos de
esta subclase. Es por ello que a la herencia se le conoce algunas veces como especialización.
 24

Lo que estamos diciendo es que todas las personas deben tener un nombre, una dirección, un teléfono, etc. Si
en nuestro modelo, Alumno es una subclase de Persona, entonces todos los alumnos también tendrán nombre,
dirección y teléfono, pero además tendrán otros atributos que son particulares de los alumnos y no existen en
una persona que no sea alumno.

Por ejemplo, los alumnos pueden tener una lista de cursos asignados.

Una posibilidad es hacer una clase Alumno en la que declaremos nuevamente todos los atributos de la clase
Persona más los atributos propios de los alumnos...Pero los lenguajes orientados a objetos permiten declarar
explícitamente que una clase es subclase de otra.

Cuando hacemos esto, la subclase mantiene todos los atributos de la superclase sin que tengamos que
declararlos explícitamente, y podemos concentrarnos entonces en los atributos particulares de la subclase.

La subclase hereda las características de la superclase.

public class Alumno extends Persona{

private Curso[] cursos;
private int cantidadCursos;
private int maximaCantidadCursos;

public Alumno(String nom, String dir, int f) {

super(nom, dir, f);
cantidadCursos = 0;
maximaCantidadCursos = 6;
cursos = new Curso[maximaCantidadCursos];
}
public void AsignaCurso(Curso c) {
}
public int CantidadTotalCreditos() {
...
}
}
En el constructor de una subclase lo primero que encontramos es una llamada al constructor de la clase padre
con super(…..) que nos permite tener el acceso al constructor de Persona

LA HERENCIA COMO ESPECIALIZACIÓN

La relación de herencia es de especialización hacia las subclases y de generalización en sentido opuesto. Con la
herencia sólo podemos aumentar o concretar la funcionalidad que ya teníamos en la superclase: esto es,
básicamente, añadir atributos y métodos, y cambiar la implementación de algunos métodos. No podemos
eliminar métodos o atributos.
 25

Se desea manejar una aplicación que maneje un catálogo de prendas con las siguientes funcionalidades:
1. Debe permitir ingresar información sobre las prendas que conforman el catálogo que son: Camisetas,
Pantalones y Calcetines
2. Debe almacenar esta información de manera permanente, de tal modo que pueda ser usada más
adelante.
3. Debe brindar una función de búsqueda que permita por ejemplo encontrar todos los pantalones de una
talla
4. Debe permitir imprimir listados, como por ejemplo de todas las camisetas que hay en la base o un
listado con todos los calcetines de hombre.
5. Debe permitir eliminar información
Por cada Camiseta se almacena Por cada pantalón se registra De cada par de calcetines se
guarda
• Código o identificador • Código o identificador • Código o identificador
• Precio • Precio • Precio
• Talla • Talla • Talla
• Color • Color • Color
• Corte • Corte • Género
• Género
 26

Al trabajar la aplicación con este diseño de clases el código quedaría duplicado o redundante debido a que las
clases Camiseta, Pantalón y Calcetín tienen muchas características o atributos en común. La solución es simple.
En lugar de definir las clases Camiseta, Pantalón y Calcetín completamente independientes, se define primero
una clase que contiene todas las características que tienen en común Camiseta, Pantalón y Calcetín. Esta nueva
clase se llamará Ropa y luego se declarará que una Camiseta es Ropa, que un Pantalón es Ropa y que los
Calcetines son Ropa.

El siguiente diagrama muestra la clase Ropa con todos los campos y métodos que son comunes
27
28
29
 30

En la clase Ropa se define el método mostrarDatos() que permite retornar la información completa del objeto

En la clase Camiseta se sobreescribe el método mostrarDatos() para complementar la información del objeto

Sobreescribir Métodos
Sobreescribir un método significa que una subclase reimplementa un método heredado. Para sobreescribir un
método hay que respetar totalmente la declaración del método:

• El nombre debe ser el mismo

• Los parámetros y tipo de retorno deben ser los mismos
• El modificador de acceso debe ser el mismo
• Al ejecutar un método se busca su implementación de abajo hacia arriba en la jerarquía de clases.

Buscar datos

Ejercicio Herencia: Se requiere manejar los datos de una cuenta bancaria, las cuentas se identifican por un
número único, el nombre del cliente y el saldo inicial. Dentro de la entidad bancaria existen dos tipos de
cuentas: de ahorros y corriente. La cuenta de ahorros tiene un porcentaje que indica la utilidad sobre el saldo
diario, y la corriente debe incluir el valor de la chequera. Para todos los tipos de cuentas se realizan
consignaciones y retiros sobre el saldo.

Se debe realizar una aplicación que permita manejar las cuentas, definir las clases que considere pertinentes.
Cada clase debe tener un método constructor con sus parámetros, métodos consultores, modificadores y
analizadores que sean necesarios.