Notas POO 2008 PDF

PROGRAMACIÓN ORIENTADA
A OBJETOS
CON C++, JAVA Y RUBY
Notas de clase
C++
Elaborado por:
Carlos Alberto Fernández y Fernández
Instituto de Electrónica y Computación
Universidad Tecnológica de la Mixteca
Primavera 2008
Programación Orientada a Objetos
con C++, Java y Ruby
Contenido
Eclipse ................................................................................................................ 12
Características de C++...................................................................................... 15
Comentarios en C++........................................................................................ 15
Flujo de entrada/salida..................................................................................... 15
Funciones en línea............................................................................................ 16
Declaraciones de variables............................................................................... 18
Operador de resolución de alcance .................................................................. 19
Valores por Default .......................................................................................... 21
Parámetros por referencia................................................................................ 23
Variables de referencia ................................................................................... 24
Asignación de memoria en C++....................................................................... 26
Plantillas .......................................................................................................... 30
Introducción a la programación orientada a objetos [2, 3] ............................ 34
Programación no estructurada ......................................................................... 34
Programación procedural ................................................................................ 34
Programación modular..................................................................................... 35
Datos y Operaciones separados ....................................................................... 36
Programación orientada a objetos ................................................................... 37
Tipos de Datos Abstractos ................................................................................ 38
Los Problemas................................................................................................ 38
Tipos de Datos Abstractos y Orientación a Objetos ....................................... 39
Conceptos de básicos de objetos....................................................................... 40
Lenguajes de programación orientada a objetos .............................................. 43

-2-
C..................................................................................................................... 44
Introducción a Java........................................................................................... 46
Origen............................................................................................................... 46
Características de diseño.................................................................................. 47
Simple y familiar............................................................................................ 47
Orientado a Objetos........................................................................................ 48
Independiente de la plataforma....................................................................... 48
Portable .......................................................................................................... 49
Robusto .......................................................................................................... 49
Diferencias entre Java y C++ .......................................................................... 51
Archivos .java y .class ...................................................................................... 53
Programas generados con java ........................................................................ 53
El Java Developer’s Kit .................................................................................... 54
Compilación ................................................................................................... 54
“Hola Mundo” ................................................................................................. 56
Hola mundo básico en Java ............................................................................ 56
Hola mundo básico en C++ ............................................................................ 57
Hola mundo en un Java Applet....................................................................... 57
Archivo HTML .............................................................................................. 59
Ejecución........................................................................................................ 59
Hola mundo en Eclipse................................................................................... 60
Fundamentos del Lenguaje Java...................................................................... 61
Comentarios ..................................................................................................... 61
Tipos de datos................................................................................................... 62
Tipos de datos simples ................................................................................... 63
Referencias a objetos...................................................................................... 64
Identificadores .................................................................................................. 64
Variables .......................................................................................................... 65
Ámbito de una variable. ................................................................................. 66

-3-
Operadores ....................................................................................................... 69
Operadores aritméticos:.................................................................................. 69
Operadores relacionales: ................................................................................ 71
Operadores lógicos:........................................................................................ 72
Operadores de bits:......................................................................................... 73
Operadores de asignación:.............................................................................. 74
Precedencia de operadores en Java................................................................. 74
Valores literales................................................................................................ 75
Literales lógicos ............................................................................................. 75
Literales de tipo entero ................................................................................... 76
Literales de tipo real ....................................................................................... 76
Literales de tipo carácter ................................................................................ 77
Literales de tipo String ................................................................................... 78
Estructuras de control ...................................................................................... 79
Estructuras condicionales ............................................................................... 79
Ciclos. ............................................................................................................ 83
Saltos.............................................................................................................. 87
Arreglos ............................................................................................................ 88
Enumeraciones ................................................................................................. 92
Introducción a Ruby ......................................................................................... 94
Características ................................................................................................. 94
Comparado con C........................................................................................... 95
Comparado con C++ ...................................................................................... 96
Comparado con Java ...................................................................................... 97
Herramientas .................................................................................................... 98
Ruby: Fundamentos del lenguaje..................................................................... 99
Convenciones léxicas........................................................................................ 99
Literales.......................................................................................................... 100
Variables ........................................................................................................ 101
Operadores ..................................................................................................... 103
-4-
Arreglos .......................................................................................................... 106

Probando Ruby ............................................................................................... 109
Estructuras de control .................................................................................... 110
Entrada y Salida básica en Ruby .................................................................... 118
Abstracción de datos: Clases y objetos .......................................................... 119
Clases ............................................................................................................. 119
Objetos e instancias........................................................................................ 120
Instanciación ................................................................................................ 120
Clases en C++................................................................................................ 121
Miembros de una clase en C++...................................................................... 122
Atributos miembro ....................................................................................... 122
Métodos miembro ........................................................................................ 122
Un vistazo al acceso a miembros.................................................................. 124
Objetos de clase en C++ ................................................................................ 126
Clases en Java ................................................................................................ 129
Miembros de una clase en Java ...................................................................... 130
Métodos miembro ........................................................................................ 131
Un vistazo al acceso a miembros.................................................................. 131
Objetos de clase en Java................................................................................. 132
Asignación de memoria al objeto ................................................................. 132
Clases en Ruby ............................................................................................... 136
Miembros de una clase en Ruby ..................................................................... 136
Métodos miembro ........................................................................................ 137
Un vistazo al acceso a métodos .................................................................... 138
Objetos de clase en Ruby ................................................................................ 140
Asignación de memoria al objeto ................................................................. 140
Alcance de Clase en C++ ............................................................................... 144
-5-
Alcance de Clase en Java ............................................................................... 144

Alcance de Clase en Ruby............................................................................... 145
Usando la palabra reservada this en C++ y Java .......................................... 146
Usando la palabra reservada self en Ruby ..................................................... 147
Sobrecarga de operaciones............................................................................. 148
Constructores y destructores en C++............................................................. 150
Constructor................................................................................................... 150
Constructor de Copia.................................................................................... 151
Destructor..................................................................................................... 153
Constructores y finalizadores en Java ............................................................ 156
Constructor................................................................................................... 156
Finalizador ................................................................................................... 157
Inicializadores en Ruby .................................................................................. 158
Miembros estáticos en C++ ........................................................................... 160
Miembros estáticos en Java ............................................................................ 163
Miembros de clase en Ruby ............................................................................ 166
Atributos de clase ......................................................................................... 166
Métodos de clase .......................................................................................... 166
Objetos constantes en C++ ............................................................................ 168
Objetos finales en Java ................................................................................... 171
Objetos constantes en Ruby ............................................................................ 173
Funciones amigas en C++ ............................................................................... 176
Sobrecarga de operadores en C++ ................................................................. 181

Algunas restricciones: .................................................................................... 181
Sobrecarga de operadores en Ruby ............................................................... 191
Herencia en C++.............................................................................................. 193

-6-
Introducción ................................................................................................... 193

Implementación en C++................................................................................. 194
Control de Acceso a miembros en C++.......................................................... 196
Control de acceso en herencia en C++ .......................................................... 198
Manejo de objetos de la clase base como objetos de una clase derivada y
viceversa en C++ ........................................................................................... 202
Constructores de clase base en C++ .............................................................. 206
Redefinición de métodos en C++.................................................................... 209
Herencia Múltiple en C++ ............................................................................. 212
Ambigüedades.............................................................................................. 216
Constructores en herencia múltiple .............................................................. 220
Herencia en Java ............................................................................................. 221
Implementación en Java ................................................................................. 221
BlueJ............................................................................................................... 223
Clase Object ................................................................................................... 226
Control de acceso a miembros en Java........................................................... 227
Control de acceso de clase public en Java...................................................... 230
Constructores de superclase ........................................................................... 230
Manejo de objetos de la subclase como objetos de una superclase en Java ... 231
Redefinición de métodos ................................................................................. 235
Calificador final ............................................................................................. 237
Interfaces ......................................................................................................... 238
Herencia en Ruby............................................................................................ 243

Implementación en Ruby................................................................................. 243
Clase Class ..................................................................................................... 244
Clase Object ................................................................................................... 245
-7-
Control de acceso a miembros en Ruby .......................................................... 246

Inicializadores de superclase.......................................................................... 249
Manejo de objetos de la subclase como objetos de una superclase en Ruby... 250
Redefinición de métodos ................................................................................. 252
Módulos............................................................................................................ 254
Mixins............................................................................................................... 255
Asociaciones entre clases en C++ ................................................................... 259

Asociaciones reflexivas en C++ ..................................................................... 261
Multiplicidad de una asociación en C++ ....................................................... 262
Tipos de asociaciones según su multiplicidad .............................................. 262
Asociaciones entre Clases en Java.................................................................. 266
Asociación reflexiva en Java .......................................................................... 267
Multiplicidad de una asociación en Java........................................................ 267
Asociaciones entre Clases en Ruby ................................................................ 271
Asociación reflexiva en Ruby.......................................................................... 271
Multiplicidad de una asociación en Ruby ....................................................... 272
Objetos compuestos en C++............................................................................ 273
UMLGEC ++ ................................................................................................... 277
Objetos compuestos en Java ........................................................................... 279
Objetos compuestos en Ruby.......................................................................... 284
Funciones virtuales y polimorfismo en C++ .................................................. 289

Clase abstracta y clase concreta en C++....................................................... 292
-8-
Polimorfismo .................................................................................................. 293

Destructores virtuales..................................................................................... 294
Clases Abstractas y Polimorfismo en Java .................................................... 309
Clase abstracta y clase concreta en Java ....................................................... 311
Ejemplo de Polimorfismo con una Interfaz en Java........................................ 323
Polimorfismo en Ruby .................................................................................... 325
¿Y la clase abstracta?..................................................................................... 327
Plantillas de clase en C++ ............................................................................... 337
Standard Template Library (STL) ................................................................ 341
Clases Genéricas en Java................................................................................. 344
Biblioteca de Clases Genéricas en Java ......................................................... 347
Manejo de Excepciones ................................................................................... 350
Manejo de Excepciones en C++...................................................................... 351

Excepciones estandar en C++........................................................................ 352
Manejo de Excepciones en Java ..................................................................... 354
¿Cómo funciona?............................................................................................ 354
Lanzamiento de excepciones (throw) .............................................................. 355
Manejo de excepciones ................................................................................... 356
El bloque try................................................................................................. 357
El bloque catch............................................................................................. 357
El bloque finally ........................................................................................... 359
Jerarquía de excepciones................................................................................ 361
Ventajas del tratamiento de excepciones ...................................................... 362
-9-
Lista de Excepciones ................................................................................... 363

Afirmaciones en Java ...................................................................................... 367
Usando afirmaciones ...................................................................................... 367
Habilitando y deshabilitando las afirmaciones............................................... 368
Manejo de Excepciones en Ruby .................................................................... 370
Raise & Rescue............................................................................................... 370
Jerarquía de Excepciones ............................................................................... 372
Catch & Throw ............................................................................................... 373
Introducción a Multihilos en Java ................................................................. 375
Programas de flujo múltiple ......................................................................... 375
Estados de un hilo........................................................................................... 377
La clase Thread .............................................................................................. 379
Comportamiento de los hilos .......................................................................... 380
Interfaz Gráfica AWT .................................................................................... 383
Clases de ventana ........................................................................................... 383
Clase Frame.................................................................................................. 384
Clase Dialog ................................................................................................. 384
Clase Filedialog............................................................................................ 384
Componentes gráficos .................................................................................... 385
Aplicaciones con menús.................................................................................. 390
Clase MenuBar............................................................................................. 390
Clase Menu .................................................................................................. 390
Clase MenuItem ........................................................................................... 391
Manejo de Eventos .......................................................................................... 394
Introducción ................................................................................................... 394
Modelo de manejo de eventos actual .............................................................. 395
- 10 -
Adaptadores ................................................................................................. 399

Otras tecnologías Java .................................................................................... 407
Principales tecnologías de Java EE................................................................ 408
Otras tecnologías (no necesariamente Java).................................................. 410
Referencias....................................................................................................... 413

- 11 -
Eclipse
Eclipse es desarrollado como un proyecto de codigo abierto lanzada en

noviembre de 2001 por IBM, Object Technology Internacional y otras compañias.
El objetivo era desarrollar una plataforma abierta de desarrollo. Fue planeada para
ser extendida mediante plug-ins.
Es desarrollada en Java por lo que puede ejecutarse en un amplio rango de

sistemas operativos. Tambien incorpora facilidades para desarrollar en Java
aunque es posible instalarle plug-ins para otros lenguajes como C/C++, PHP,
Ruby, Haskell, etc. Incluso antiguos lenguajes como Cobol tienen extensiones
disponibles para Eclipse [1]:
• Eclipse + JDT = Java IDE

• Eclipse + CDT = C/C++ IDE
• Eclipse + PHP = PHP IDE
• Eclipse + JDT + CDT + PHP = Java, C/C++, PHP IDE
• …
Trabaja bajo “workbenchs” que determinan la interfaz del usuario centrada

alrededor del editor, vistas y perspectivas.

- 12 -
Los recursos son almacenados en el espacio de trabajo (workspace) el cual es un

fólder almacenado normalmente en el directorio de Eclipse. Es posible manejar
diferentes áreas de trabajo.
Eclipse, sus componentes y documentación pueden ser obtenidos de:

www.eclipse.org
Para trabajar en este curso se requerirá preferentemente:
1. Java 1.5 o 1.6

2. Eclipse SDK 3.3.x
3. Plug in para C/C++ en Eclipse (CDT) y compilador de ANSI C/C++ si no
se tiene uno instalado.
4. Ruby 1.8

- 13 -
5. Plug in para Ruby (RDT – Rubt Development Tools) si se quiere usar Ruby
con Eclipse
Tips para instalar CDT (C/C++ Development Toolkit) en Eclipse en Windows:
1. Instalar un compilador de C/C++

a. Si se instala MinGW y se tiene que renombrar el archivo mingw32-
make.exe por make.exe. Ver http://www.mingw.org
b. Además, añadir el depurador gdb pues no viene incluido en MinGW,
aunque existe una copia en el sitio antes mencionado o puede
obtenerse de: http://sourceware.org/gdb
2. Instalar el CDT desde el sitio recomendado Usando el Update Manager y
obteniendo el plug in del sitio Callisto Discovery que aparece listado al
entrar a añadir componentes en el Update Manager (Otra opcion es ir a
http://www.eclipse.org/cdt/ )
3. Agregar \MinGW\bin (o el directorio correspondiente) al la variable PATH
del sistema.
Si el CDT esta bien instalado debe ser posible crear proyectos de C/C++,
compilarlos, ejecutarlos y depurarlos dentro del ambiente de Eclipse.
En el caso de Ruby, el interprete puede obtenerse de: http://www.ruby-

lang.org/en/downloads/
El RDT para eclipse se instala como el CDT y se obtiene de:

http://rubyeclipse.sourceforge.net/download.rdt.html
Posteriormente se tiene que especificar en Eclipse la ruta del interprete.

- 14 -
Características de C++
Ahora comentaremos algunas características de C++ que no tienen que ver

directamente con la programación orientada a objetos.
Comentarios en C++
Los comentarios en C son:
/* comentario en C */
En C++ los comentarios pueden ser además de una sola línea:

// este es un comentario en C++
Acabando el comentario al final de la línea, lo que quiere decir que el

programador no se preocupa por cerrar el comentario.
Flujo de entrada/salida
En C, la salida y entrada estándar estaba dada por printf y scanf principalmente

(o funciones similares) para el manejo de los tipos da datos simples y las cadenas.
En C++ se proporcionan a través de la librería iostream, la cual debe ser
insertada a través de un #include. Las instrucciones son:
- cout Utiliza el flujo salida estándar.

Que se apoya del operador <<, el cual se conoce como operador
de inserción de flujo "colocar en"
- cin Utiliza el flujo de entrada estándar.

Que se apoya del operador >>, conocido como operador de
extracción de flujo "obtener de"

- 15 -
Los operadores de inserción y de extracción de flujo no requieren cadenas

de formato (%s, %f), ni especificadores de tipo. C++ reconoce de manera
automática que tipos de datos son extraídos o introducidos.
En el caso de el operador de extracción (>>) no se requiere el operador de

dirección &.
De tal forma un código de desplegado con printf y scanf de la forma (usando

el area de nombres estandar):
printf("Número: ");
scanf("%d", &num);
printf("El valor leído es: " %d\n", num);
Sería en C++ de la siguiente manera:
cout << "Número";

cin >> num;
cout << "El valor leído es: " << num << '\n';
Funciones en línea
Las funciones en línea, se refiere a introducir un calificador inline a una

función de manera que le sugiera al compilador que genere una copia del código
de la función en lugar de la llamada.
Ayuda a reducir el número de llamadas a funciones reduciendo el tiempo de

ejecución en algunos casos, pero en contraparte puede aumentar el tamaño del
programa.
A diferencia de las macros, las funciones inline si incluyen verificación de

tipos y son reconocidas por el depurador.
Las funciones inline deben usarse sólo para funciones chicas que se usen
frecuentemente.

- 16 -
El compilador desecha las solicitudes inline para programas que incluyan un

ciclo, un switch o un goto. Tampoco se consideran si no tienen return (aunque no
regresen valores) o si contienen variables de tipo static. Y lógicamente no genera
una función inline para funciones recursivas.
Declaración:
inline <declaración de la función>
Ejemplo:
inline float suma (float a, float b) {

Return a+b;
}
inline int max( int a, int b) {

return (a > b) ? a : b;
}
Nota: Las funciones inline tienen conflictos con los prototipos, así que
deben declararse completas sin prototipo en el archivo .h. Además, si la función
hace uso de otra función en donde se expanda la función debe tener los include
correspondientes a esas funciones utilizadas.

- 17 -
Declaraciones de variables
Mientras que en C, las declaraciones deben ir en la función antes de

cualquier línea ejecutable, en C++ pueden ser introducidas en cualquier punto,
con la condición lógica de que la declaración esté antes de la utilización de lo
declarado.
En algunos compiladores podia declararse una variable en la sección de

inicialización de la instrucción for, pero es incorrecto declarar una variable en la
expresión condicional del while, do-while, for, if o switch. El actual estandar de
C++ no permite la declaracion de variables dentro del for.
Ejemplo:
#include <iostream>
int main() {
int i=0;
for (i=1; i<10; i++){

int j=10;
std::cout<<i<<" j: "<<j<<std::endl;
}
std::cout<<"\ni al salir del ciclo: "<<i;
return 0;
}

- 18 -
O usando el area de nombres estandar:
#include <iostream>
using namespace std;
int main() {
int i=0;
for (i=1; i<10; i++){

int j=10;
cout<<i<<" j: "<<j<<endl;
}
cout<<"\ni al salir del ciclo: "<<i;
return 0;
}
El alcance de las variables en C++ es por bloques. Una variable es vista a

partir de su declaración y hasta la llave “}” del nivel en que se declaró. Lo cual
quiere decir que las instrucciones anteriores a su declaración no pueden hacer uso
de la variable, ni después de finalizado el bloque.
Operador de resolución de alcance
Se puede utilizar el operador de resolución de alcance :: se refiere a una

variable (variable, función, tipo, enumerador u objeto), con un alcance de archivo
(variable global).
Esto le permite al identificador ser visible aún si el identificador se
encuentra oculto.
Ejemplo:
float h;
- 19 -
void g(int h) {
float a;
int b;
a=::h; // a se inicializa con la variable global h
b=h; // b se inicializa con la variable local h

}

- 20 -
Valores por Default
Las funciones en C++ pueden tener valores por default. Estos valores son
los que toman los parámetros en caso de que en una llamada a la función no se
encuentren especificados.
Los valores por omisión deben encontrarse en los parámetros que estén más
a la derecha. Del mismo modo, en la llamada se deben empezar a omitir los
valores de la extrema derecha.
Ejemplo:
#include <iostream>
int punto(int=5, int=4);
int main () {
cout<<"valor 1: "<<punto()<<'\n';
cout<<"valor 2: "<<punto(1)<<'\n';
cout<<"valor 3: "<<punto(1,3)<<'\n';
getchar();
return 0;
}
int punto( int x, int y){
if(y!=4)
return y;
if(x!=5)
return x;
return x+y;
}

- 21 -
C++ no permite la llamada omitiendo un valor antes de la extrema derecha

de los argumentos:
punto( , 8);
Otro ejemplo de valores o argumentos por default:

#include <iostream>
int b=1;
int f(int);
int h(int x=f(b)); // argumento default f(::b)
int main () {
b=5;
cout<<b<<endl;
{
int b=3;
cout<<b<<endl;
cout<<h(); //h(f(::b))
}
return 0;
}
int h(int z){

cout<<"Valor recibido: "<<z<<endl;
return z*z;
}
int f(int y){
return y;
}

- 22 -
Parámetros por referencia
En C todos los pasos de parámetros son por valor, aunque se pueden enviar
parámetros "por referencia" al enviar por valor la dirección de un dato (variable,
estructura, objeto), de manera que se pueda accesar directamente el área de
memoria del dato del que se recibió su dirección.
C++ introduce parámetros por referencia reales. La manera en que se
definen es agregando el símbolo & de la misma manera que se coloca el *:
después del tipo de dato en el prototipo y en la declaración de la función.
Ejemplo:
// Comparando parámetros por valor, por valor con

// apuntadores ("referencia"),
// y paso por referencia real
#include <iostream>
int porValor(int);
void porApuntador(int *);
void porReferencia( int &);
int main() {
int x=2;
cout << "x= " << x << " antes de llamada a porValor \n"
<< "Regresado por la función: "<< porValor(x)<<endl
<< "x= " << x << " despues de la llamada a
porValor\n\n";
int y=3;
cout << "y= " << y << " antes de llamada a
porApuntador\n";
porApuntador(&y);
cout << "y= " << y << " despues de la llamada a
porApuntador\n\n";

- 23 -
int z=4;
cout << "z= " << z << " antes de llamada a porReferencia
\n";
porReferencia(z);
cout<< "z= " << z << " despues de la llamada a
porReferencia\n\n";
return 0;
}
int porValor(int valor){

return valor*=valor; //parámetro no modificado
}
void porApuntador(int *p){

*p *= *p; // parámetro modificado
}
void porReferencia( int &r){

r *= r; //parámetro modificado
}
Notar que no hay diferencia en el manejo de un parámetro por referencia y

uno por valor, lo que puede ocasionar ciertos errores de programación.
Variables de referencia
También puede declararse una variable por referencia que puede ser
utilizada como un seudónimo o alias. Ejemplo:
int max=1000, &sMax=max; //declaro max y sMax es un alias

de max
sMax++; //incremento en uno max a través de su alias
Esta declaración no reserva espacio para el dato, pues es como un apuntador

pero se maneja como una variable normal. No se permite reasignarle a la variable
por referencia otra variable.
- 24 -
Ejemplo:
// variable por referencia
#include <iostream>
int main() {
int x=2, &y=x, z=8;
cout << "x= "<<x <<endl

<<"y= "<<y<<endl;
y=10;
cout << "x= "<<x <<endl
<<"y= "<<y<<endl;
// Reasignar no esta permitido
/* &y=&z;
cout << "z= "<<z <<endl
<<"y= "<<y<<endl;
*/
y++;
cout << "z= "<<z <<endl
<<"y= "<<y<<endl;
return 0;
}

- 25 -
Asignación de memoria en C++
En el ANSI C, se utilizan malloc, calloc y free para asignar y liberar

dinámicamente memoria:
float *f;
f = (float *) malloc(sizeof(float));
. . .
free(f);
Se debe indicar el tamaño a través de sizeof y utilizar una máscara (cast)

para designar el tipo de dato apropiado.
En C++, existen dos operadores para asignación y liberación de memoria

dinámica: new y delete.
float *f;
f= new float;
. . .
delete f;
El operador new crea automáticamente un área de memoria del tamaño

adecuado. Si no se pudo asignar le memoria se regresa un apuntador nulo (NULL
ó 0). Nótese que en C++ se trata de operadores que forman parte del lenguaje, no
de funciones de biblioteca.
El operador delete libera la memoria asignada previamente por new. No se

debe tratar de liberar memoria previamente liberada o no asignada con new.
Es posible hacer asignaciones de memoria con inicialización:

int *max= new int (1000);
También es posible crear arreglos dinámicamente:
char *cad;
- 26 -
cad= new char [30];

. . .
delete [] cad;
Usar delete sin los corchetes para arreglos dinamicos puede no liberar
adecuadamente la memoria, sobre todo si son elementos de un tipo definido por el
usuario.
Ejemplo 1:
#include <iostream>
int main() {
int *p,*q;
p= new int; //asigna memoria
if(!p) {
cout<<"No se pudo asignar memoria\n";
return 0;
}
*p=100;
cout<<endl<< *p<<endl;
q= new int (123); //asigna memoria

cout<<endl<< *q<<endl;
delete p; //libera memoria

// *p=20; Uso indebido de p pues ya se libero
// cout<<endl<< *p<<endl; la memoria
delete q;
return 0;
}

- 27 -
Ejemplo 2:
#include <iostream>
int main() {
float *ap, *p=new float (3) ;
const int MAX=5;
ap= new float [MAX]; //asigna memoria
int i;
for(i=0; i<MAX; i++)
ap[i]=i * *p;
for(i=0; i<MAX; i++)
cout<<ap[i]<<endl;
delete p;
delete [] ap;
return 0;
}
Ejemplo 3:
#include <iostream>
typedef struct {
int n1,
n2,
n3;
}cPrueba;
int main() {
cPrueba *pr1, *pr2;
pr1= new cPrueba;

pr1->n1=11;
pr1->n2=12;
pr1->n3=13;
pr2= new cPrueba(*pr1);

- 28 -
delete pr1;
cout<< pr2->n1<<" "<<pr2->n2 <<" "<<pr2->n3<<endl;
delete pr2;
return 0;
}

- 29 -
Plantillas
Cuando las operaciones son idénticas pero requieren de diferentes tipos de

datos, podemos usar lo que se conoce como templates o plantillas de función.
El término de plantilla es porque el código sirve como base (o plantilla) a

diferentes tipos de datos. C++ genera al compilar el código objeto de las
funciones para cada tipo de dato involucrado en las llamadas
Las definiciones de plantilla se escriben con la palabra clave template, con una
lista de parámetros formales entre < >. Cada parámetro formal lleva la palabra
clave class.
Cada parámetro formal puede ser usado para sustituir a: tipos de datos básicos,
estructurados o definidos por el usuario, tipos de los argumentos, tipo de regreso
de la función y para variables dentro de la función.
Ejemplo 1:
#include <iostream>
template <class T>

T mayor(T x, T y)
{
return (x > y) ? x : y;
};
int main(){
int a=10, b=20, c=0;
float x=44.1, y=22.3, z=0 ;
c=mayor(a, b);
z=mayor(x, y);
cout<<c<<" "<<z<<endl;
// z=mayor(x,b); error no hay mayor( float, int)

- 30 -
// z=mayor(a, y); "" "" "" "" (int, float)
return 0;
}
Consideraciones:
• Cada parámetro formal debe aparecer en la lista de parámetros de la función al
menos una vez.
• No puede repetirse en la definición de la plantilla el nombre de un parámetro
formal.
• Tener cuidado al manejar mas de un parámetro en los templates.
Ejemplo 2:
#include <iostream>
template <class T>

void desplegaArr(T arr[], const int cont, T pr)
{
for(int i=0; i<cont; i++)
cout<< arr[i] << " ";
cout<<endl;
cout<<pr<<endl;
}
int main() {
const int contEnt=4, contFlot=5, contCar=10;
int ent[]={1,2,3,4};
float flot[]={1.1, 2.2, 3.3, 4.4, 5.5};
char car[]={"Plantilla"};
cout<< "Arreglo de flotantes:\n";

desplegaArr(flot, contFlot,(float)3.33);

- 31 -
cout<< "Arreglo de caracteres:\n";

desplegaArr(car, contCar, 'Z');
cout<< "Arreglo de enteros:\n";

desplegaArr(ent, contEnt, 99);
return 0;
}
Ejemplo 3:
#include <iostream>
template <class T, class TT>

T mayor(T x, TT y)
{
return (x > y) ? x : y;
};
int main(){
int a=10, b=20, c=0;

float x=44.1, y=22.3, z=0 ;
c=mayor(a, b);
z=mayor(x, y);
cout<<c<<" "<<z<<endl;
//sin error al aumentar un parámetro formal.
z=mayor(x,b);
cout<<z<<endl;
z=mayor(a,y); //regresa entero pues a es entero (tipo T es
entero para
cout<<z<<endl; // este llamado.
z=mayor(y, a);
cout<<z<<endl;

- 32 -
c=mayor(y, a);//regresa flotante pero la asignaci¢n lo

corta en entero.
cout<<c<<endl;
return 0;
}

- 33 -
Introducción a la programación orientada a objetos [2, 3]
Programación no estructurada
Comúnmente, las personas empiezan a aprender a programar escribiendo

programas pequeños y sencillos consistentes en un solo programa principal.
Aquí "programa principal" se refiere a una secuencia de comandos o

instrucciones que modifican datos que son a su vez globales en el transcurso de
todo el programa.
Programación procedural
Con la programación procedural se pueden combinar las secuencias de

instrucciones repetitivas en un solo lugar.
Una llamada de procedimiento se utiliza para invocar al procedimiento.
Después de que la secuencia es procesada, el flujo de control procede

exactamente después de la posición donde la llamada fue hecha.

- 34 -
Al introducir parámetros, así como procedimientos de procedimientos

(subprocedimientos) los programas ahora pueden ser escritos en forma más
estructurada y con menos errores.
Por ejemplo, si un procedimiento ya es correcto, cada vez que es usado

produce resultados correctos. Por consecuencia, en caso de errores, se puede
reducir la búsqueda a aquellos lugares que todavía no han sido revisados.
De este modo, un programa puede ser visto como una secuencia de llamadas
a procedimientos. El programa principal es responsable de pasar los datos a las
llamadas individuales, los datos son procesados por los procedimientos y, una vez
que el programa ha terminado, los datos resultantes son presentados.
Así, el flujo de datos puede ser ilustrado como una gráfica jerárquica, un
árbol, como se muestra en la figura para un programa sin subprocedimientos.
Programación modular
En la programación modular, los procedimientos con una funcionalidad común

son agrupados en módulos separados.
Un programa por consiguiente, ya no consiste solamente de una sección. Ahora

está dividido en varias secciones más pequeñas que interactúan a través de
llamadas a procedimientos y que integran el programa en su totalidad.

- 35 -
Cada módulo puede contener sus propios datos. Esto permite que cada módulo
maneje un estado interno que es modificado por las llamadas a procedimientos de
ese módulo.
Sin embargo, solamente hay un estado por módulo y cada módulo existe
cuando más una vez en todo el programa.
Datos y Operaciones separados
La separación de datos y operaciones conduce usualmente a una estructura

basada en las operaciones en lugar de en los datos: Los Módulos agrupan las
operaciones comunes en forma conjunta.
Al programar entonces se usan estas operaciones proveyéndoles

explícitamente los datos sobre los cuáles deben operar.
La estructura de módulo resultante está por lo tanto orientada a las

operaciones más que sobre los datos. Se podría decir que las operaciones
definidas especifican los datos que serán usados.
En la programación orientada a objetos, la estructura se organiza por

los datos. Se escogen las representaciones de datos que mejor se ajusten a tus

- 36 -
requerimientos. Por consecuencia, los programas se estructuran por los datos más
que por las operaciones.
Los datos especifican las operaciones válidas. Ahora, los módulos agrupan
representaciones de datos en forma conjunta.
Programación orientada a objetos
La programación orientada a objetos resuelve algunos de los problemas que

se acaban de mencionar. De alguna forma se podría decir que obliga a prestar
atención a los datos.
En contraste con las otras técnicas, ahora tenemos una telaraña de objetos
interactuantes, cada uno de los cuáles manteniendo su propio estado.
Por ejemplo, en la programación orientada a objetos deberíamos tener tantos

objetos de pila como sea necesario. En lugar de llamar un procedimiento al que
le debemos proveer el manejador de la pila correcto, mandaríamos un mensaje
directamente al objeto pila en cuestión.

- 37 -
En términos generales, cada objeto implementa su propio módulo,

permitiendo por ejemplo que coexistan muchas pilas. Cada objeto es responsable
de inicializarse y destruirse en forma correcta.
¿No es ésta solamente una manera más elegante de técnica de

programación modular?
Tipos de Datos Abstractos
Algunos autores describen la programación orientada a objetos como

programación de tipos de datos abstractos y sus relaciones. Los tipos de datos
abstractos son como un concepto básico de orientación a objetos.
Los Problemas
La primera cosa con la que uno se enfrenta cuando se escriben programas es
el problema.
Típicamente, uno se enfrenta a problemas "de la vida real" y nos queremos

facilitar la existencia por medio de un programa para manejar dichos problemas.
Sin embargo, los problemas de la vida real son nebulosos y la primera cosa
que se tiene que hacer es tratar de entender el problema para separar los detalles
esenciales de los no esenciales: tratando de obtener tu propia perspectiva
abstracta, o modelo, del problema. Este proceso de modelado se llama abstracción
y se ilustra en la Figura:

- 38 -
El modelo define una perspectiva abstracta del problema. Esto implica que
el modelo se enfoca solamente en aspectos relacionados con el problema y que
uno trata de definir propiedades del problema. Estas propiedades incluyen
• los datos que son afectados

• las operaciones que son identificadas
por el problema.
Para resumir, la abstracción es la estructuración de un problema nebuloso en

entidades bien definidas por medio de la definición de sus datos y operaciones.
Consecuentemente, estas entidades combinan datos y operaciones. No están
desacoplados unos de otras.
Tipos de Datos Abstractos y Orientación a Objetos
Los TDAs permiten la creación de instancias con propiedades bien definidas

y comportamiento bien definido. En orientación a objetos, nos referimos a los
TDAs como clases. Por lo tanto, una clase define las propiedades de objetos en un
ambiente orientado a objetos.
Los TDAs definen la funcionalidad al poner especial énfasis en los datos

involucrados, su estructura, operaciones, así como en axiomas y precondiciones.
- 39 -
Consecuentemente, la programación orientada a objetos es "programación con

TDAs”: al combinar la funcionalidad de distintos TDAs para resolver un
problema. Por lo tanto, instancias de TDAs son creadas dinámicamente, usadas y
destruídas.
Conceptos de básicos de objetos
La programación tradicional separa los datos de las funciones, mientras que

la programación orientada a objetos define un conjunto de objetos donde se
combina de forma modular los datos con las funciones.
Aspectos principales:
1) Objetos.
• El objeto es la entidad básica del modelo orientado a objetos.
• El objeto integra una estructura de datos (atributos) y un comportamiento
(operaciones).
• Se distinguen entre sí por medio de su propia identidad, aunque internamente
los valores de sus atributos sean iguales.
2) Clasificación.
• Las clases describen posibles objetos, con una estructura y comportamiento
común.
• Los objetos que contienen los mismos atributos y operaciones pertenecen a la
misma clase.
• La estructura de clases integra las operaciones con los atributos a los cuales se
aplican.
3) Instanciación.
• El proceso de crear objetos que pertenecen a una clase se denomina
instanciación.
• Pueden ser instanciados un número indefinido de objetos de cierta clase.

- 40 -
4) Generalización.
• En una jerarquía de clases, se comparten atributos y operaciones entre clases
basados en la generalización de clases.
• La jerarquía de generalización se construye mediante la herencia.
• Las clases más generales se conocen como superclases.
• Las clases más especializadas se conocen como subclases. La herencia puede
ser simple o múltiple.
5) Abstracción.
• La abstracción se concentra en lo primordial de una entidad y no en sus
propiedades secundarias.
• Además en lo que el objeto hace y no en cómo lo hace.
• Se da énfasis a cuales son los objetos y no cómo son usados.
6) Encapsulación.
• Encapsulación o encapsulamiento es la separación de las propiedades externas
de un objeto de los detalles de implementación internos del objeto.
• Al separar la interfaz del objeto de su implementación, se limita la complejidad
al mostrarse sólo la información relevante.
• Disminuye el impacto a cambios en la implementación, ya que los cambios a
las propiedades internas del objeto no afectan su interacción externa.
7) Modularidad.
• El encapsulamiento de los objetos trae como consecuencia una gran
modularidad.
• Cada módulo se concentra en una sola clase de objetos.
• Los módulos tienden a ser pequeños y concisos.
• La modularidad facilita encontrar y corregir problemas.
• La complejidad del sistema se reduce facilitando su mantenimiento.
8) Extensibilidad.
• La extensibilidad permite hacer cambios en el sistema sin afectar lo que ya
existe.
• Nuevas clases pueden ser definidas sin tener que cambiar la interfaz del resto
del sistema.

- 41 -
• La definición de los objetos existentes puede ser extendida sin necesidad de

cambios más allá del propio objeto.
9) Polimorfismo.
• El polimorfismo es la característica de definir las mismas operaciones con
diferente comportamiento en diferentes clases.
• Se permite llamar una operación sin preocuparse de cuál implementación es
requerida en que clase, siendo responsabilidad de la jerarquía de clases y no
del programador.
10) Reusabilidad de código.

• La orientación a objetos apoya el reuso de código en el sistema.
• Los componentes orientados a objetos se pueden utilizar para estructurar
librerías resuables.
• El reuso reduce el tamaño del sistema durante la creación y ejecución.
• Al corresponder varios objetos a una misma clase, se guardan los atributos y
operaciones una sola vez por clase, y no por cada objeto.
• La herencia es uno de los factores más importantes contribuyendo al
incremento en el reuso de código dentro de un proyecto.

- 42 -
Lenguajes de programación orientada a objetos
Simula I fue originalmente diseñado para problemas de simulación y fue el

primer lenguaje en el cual los datos y procedimientos estaban unificados en una
sola entidad. Su sucesor Simula , derivó definiciones formales a los conceptos de
objetos y clase.
Simula sirvió de base a una generación de lenguajes de programación

orientados a objetos. Es el caso de C++, Eiffel y Beta.
Ada (1983), se derivan de conceptos similares, e incorporan el concepto de

jerarquía de herencia. CLU -clusters- también incorpora herencia.
Smalltalk es descendiente directo de Simula, generaliza el concepto de

objeto como única entidad manipulada en los programas. Existen tres versiones
principales: Smalltalk-72, introdujo el paso de mensajes para permitir la
comunicación entre objetos. Smalltalk-76 que introdujo herencia. Smalltalk-80
se inspira en Lisp.
Lisp contribuyó de forma importante a la evolución de la programación

orientada a objetos.
Flavors maneja herencia múltiple apoyada con facilidades para la

combinación de métodos heredados.
CLOS , es el estándar del sistema de objetos de Common Lisp.
Los programas de programación orientada a objetos pierden eficiencia ante

los lenguajes imperativos, pues al ser interpretado estos en la arquitectura von
Neumann resulta en un excesivo manejo dinámico de la memoria por la constante
creación de objetos, así como una fuerte carga por la división en múltiples
operaciones (métodos) y su ocupación. Sin embargo se gana mucho en
comprensión de código y modelado de los problemas.

- 43 -
Características de los principales LPOO1
Ada 95 Eiffel Smalltalk C++ Java

Paquetes Sí No No No Sí
Herencia Simple Múltiple Simple Múltiple Simple
Control de tipos Fuerte Fuerte Sin tipos Fuerte Fuerte
Enlace Dinámico Dinámico Dinámico Dinámico Dinámico
Concurrencia Sí No No No Sí
Recolección de No Sí Sí No Sí
basura
Afirmaciones No Sí No No Si2
Persistencia No No No No No
Generecidad Sí Sí Sí Sí Si3
Otra comparación puede ser vista en la siguiente tabla, tomada de Wikipedia4:
General
Typing
Language model of Influences Paradigm(s) Introduced
discipline
execution
concurrent,
Algol, Pascal, distributed, static,
C++ (Ada 95), generic, strong,
Ada Compilation 1983
Smalltalk (Ada 95), imperative, safe,
Java (Ada 2005) object- nominative
oriented
imperative, static,
C, Simula, Algol
C++ Compilation object- strong, 1985
68
oriented, unsafe,
1
Lenguajes de Programación Orientada a Objetos
2
A partir de la version 5 (1.5) de Java
3
Idem
4
La tabla completa puede ser vista en:
http://en.wikipedia.org/wiki/Comparison_of_programming_languages
- 44 -
generic nominative
imperative,
object- static,
JIT Delphi, Java, C++, oriented, strong,
C# 2000
compilation Ruby generic, both safe
multi- and unsafe
platform
static,
imperative,
strong,
object-
Eiffel Compilation Ada, Simula safe, 1985
oriented,
nominative,
generic
contracts
imperative,
object-
Interpretation
C++, Objective-C, oriented, static,
Java / JIT 1994
C#[2] multi- strong
compilation
platform,
generic
static,
imperative, strong, safe
Object
Compilation Pascal object- (but unsafe 1985
Pascal
oriented allowed),
nominative
imperative,
object-
dynamic
oriented,
Ruby Interpretation Smalltalk,Perl,Lisp (duck), 1995
functional,
strong
aspect-
oriented
object-
oriented,
functional, dynamic,
JIT
Smalltalk Sketchpad, Simula concurrent, strong, 1971
compilation
event-driven, safe, duck
imperative,
declarative

- 45 -
Introducción a Java
Origen
Java es un lenguaje de programación orientada a objetos,

diseñado dentro de Sun Microsystems por James Gosling.
Originalmente, se le asignó el nombre de Oak y fue un lenguaje
pensado para usarse dentro de dispositivos electrodomésticos, que
tuvieran la capacidad de comunicarse entre sí.
Posteriormente fue reorientado hacia Internet, aprovechando el auge que

estaba teniendo en ese momento la red, y lo rebautizaron con el nombre de Java.
Es anunciado al público en mayo de 1995 enfocándolo como la solución para el
desarrollo de aplicaciones en web. Sin embargo, se trata de un lenguaje de
propósito general que puede ser usado para la solución de problemas diversos.
Java es un intento serio de resolver simultáneamente los problemas

ocasionados por la diversidad y crecimiento de arquitecturas
incompatibles, tanto entre máquinas diferentes como entre los diversos
sistemas operativos y sistemas de ventanas que funcionaban sobre una
misma máquina, añadiendo la dificultad de crear aplicaciones distribuidas
en una red como Internet.
El interés que generó Java en la industria fue mucho, tal que nunca un
lenguaje de programación había sido adoptado tan rápido por la comunidad de
desarrolladores. Las principales razones por las que Java es aceptado tan rápido:
• Aprovecha el inicio del auge de la Internet, específicamente del World

Wide Web.
• Es orientado a objetos, la cual si bien no es tan reciente, estaba en uno
de sus mejores momentos, todo mundo quería programar de acuerdo al
modelo de objetos.

- 46 -
• Se trataba de un lenguaje que eliminaba algunas de las principales

dificultades del lenguaje C/C++, el cuál era uno de los lenguajes
dominantes. Se decía que la ventaja de Java es que es sintácticamente
parecido a C++, sin serlo realmente.
• Java era resultado de una investigación con fines comerciales, no era
un lenguaje académico como Pascal o creado por un pequeño grupo de
personas como C ó C++.
Aunado a esto, las características de diseño de Java, lo hicieron muy

atractivo a los programadores.
Características de diseño
Es un lenguaje de programación de alto nivel, de propósito general, y cuyas

características son [5]:
• Simple y familiar.
• Orientado a objetos.
• Independiente de la plataforma
• Portable
• Robusto.
• Seguro.
• Multihilos.
Simple y familiar
Es simple, ya que tanto la estructura léxica como sintáctica del lenguaje es

muy sencilla. Además, elimina las características complejas e innecesarias de sus
predecesores.
Es familiar al incorporar las mejores características de lenguajes tales como:

C/C++, Modula, Beta, CLOS, Dylan, Mesa, Lisp, Smalltalk, Objective-C, y
Modula 3.

- 47 -
Orientado a Objetos
Es realmente un lenguaje orientado a objetos, todo en Java son objetos:
• No es posible que existan funciones que no pertenezcan a una clase.

• La excepción son los tipos da datos primitivos, como números, caracteres y
boléanos5.
Cumple con los 4 requerimientos de Wegner [6]:
OO = abstracción + clasificación + polimorfismo + herencia

Independiente de la plataforma
La independencia de la plataforma implica que un programa en Java se

ejecute sin importar el sistema operativo que se este ejecutando en una máquina
en particular. Por ejemplo un programa en C++ compilado para Windows, debe
ser al menos vuelto a compilar si se quiere ejecutar en Unix; además,
posiblemente habrá que ajustar el código que tenga que ver con alguna
característica particular de la plataforma, como la interfaz con el usuario.
Java resuelve el problema de la distribución binaria mediante un formato de

código binario (bytecode) que es independiente del hardware y del sistema
operativo gracias a su máquina virtual.
Si el sistema de runtime o máquina virtual está disponible para una

plataforma específica, entonces una aplicación puede ejecutarse sin necesidad de
un trabajo de programación adicional.
Aplicación
Runtime Java
S.O.
Hardware
5
Los puristas objetarían que no es totalmente orientado a objetos. En un sentido estricto Smalltalk es un
lenguaje “más” puro, ya que ahí hasta los tipos de datos básicos son considerados objetos.
- 48 -
Portable
Una razón por la que los programas en Java son portables es precisamente
que el lenguaje es independiente de la plataforma.
Además, la especificación de sus tipos de datos primitivos y sus tamaños,

así como el comportamiento de los operadores aritméticos, son estándares en
todas las implementaciones de Java. Por lo que por ejemplo, un entero es definido
de un tamaño de 4 bytes, y este espacio ocupará en cualquier plataforma, por lo
que no tendrá problemas en el manejo de los tipos de datos. En cambio, un entero
en C generalmente ocupa 2 bytes, pero en algunas plataformas el entero ocupa 4
bytes, lo que genera problemas a la hora de adaptar un programa de una
plataforma a otra.
Robusto
Java se considera un lenguaje robusto y confiable, gracias a:
• Validación de tipos. Los objetos de tipos compatibles pueden ser asignados

a otros objetos sin necesidad de modificar sus tipos. Los objetos de tipos
potencialmente incompatibles requieren un modificador de tipo (cast).
Si la modificación de tipo es claramente imposible, el compilador lo
rechaza y reporta un error en tiempo de compilación. Si la modificación
resulta legal, el compilador lo permite, pero inserta una validación en
tiempo de ejecución.
Cuando el programa se ejecuta se realiza la validación cada vez que se
ejecuta una asignación potencialmente inválida.
• Control de acceso a variables y métodos. Los miembros de una clase

pueden ser privados, públicos o protegidos6.
6
Más adelante en el curso se ahondará en el tema.
- 49 -
En java una variable privada, es realmente privada. Tanto el

compilador como la máquina virtual de Java, controlan el acceso a los
miembros de una clase, garantizando así su privacidad.
• Validación del apuntador Null. Todos los programas en Java usan

apuntadores para referenciar a un objeto. Esto no genera inestabilidad pues
una validación del apuntador a Null ocurre cada vez que un apuntador deja
de referencia a un objeto. C y C++ por ejemplo, no tienen esta
consideración sobre los apuntadores, por lo que es posible estar
referenciando a localidades inválidas de la memoria.
• Limites de un arreglo. Java verifica en tiempo de ejecución que un

programa no use arreglos para tratar de acceder a áreas de memoria que no
le pertenecen. De nuevo, C y C++ no tiene esta verificación, lo que permite
que un programa se salga del límite mayor y menor de un arreglo.
• Aritmética de apuntadores. Aunque todos los objetos se manejan con

apuntadores, Java elimina la mayor parte de los errores de manejo de
apuntadores porque no soporta la aritmética de apuntadores:
o No soporta acceso directo a los apuntadores

o No permite operaciones sobre apuntadores.
• Manejo de memoria. Muchos de los errores de la programación se deben a

que el programa no libera la memoria que debería liberar, o se libera la
misma memoria más de una vez.
Java, hace recolección automática de basura, liberando la memoria y

evitando la necesidad de que el programador se preocupe por liberar
memoria que ya no utilice.

- 50 -
Diferencias entre Java y C++
Se compara mucho al lenguaje de Java con C++, y esto es lógico debido a la

similitud en la sintaxis de ambos lenguajes, por lo que resulta necesario resaltar
las diferencias principales que existen entre estos. Java a diferencia de C++:
• No tiene aritmética de apuntadores. Java si tiene apuntadores, sin

embargo no permite la manipulación directa de las direcciones de memoria.
No se proporcionan operadores para el manejo de los apuntadores pues no
se considera responsabilidad del programador.
• No permite funciones con ámbito global. Toda operación debe estar

asociada a una clase, por lo que el ámbito de la función esta limitado al
ámbito de la clase.
• Elimina la instrucción goto. La instrucción goto se considera obsoleta, ya

que es una herencia de la época de la programación no estructurada. Sin
embargo, esta definida como palabra reservada para restringir su uso.
• Las cadenas no terminan con ‘\0’. Las cadenas en C y C++ terminan con
‘\0’ que corresponde al valor en ASCII 0, ya que en estos lenguajes no
existe la cadena como un tipo de dato estándar y se construye a partir de
arreglos de caracteres. En Java una cadena es un objeto de la clase String y
no necesita ese carácter para indicar su finalización.
• No maneja macros. Una macro es declarada en C y C++ a través de la

instrucción #define, la cual es tratada por el preprocesador.
• No soporta un preprocesador. Una de las razones por las cuales no maneja

macros Java es precisamente porque no tiene un preprocesador que prepare
el programa previo a la compilación.
• El tipo char contiene 16 bits. Un carácter en Java utiliza 16 bits en lugar

de 8 para poder soportar UNICODE en lugar de ASCII, lo que permite la
representación de múltiples símbolos.
- 51 -
• Java soporta múltiples hilos de ejecución. Los múltiples hilos de

ejecución o multihilos permiten un fácil manejo de programación
concurrente. Otros lenguajes dependen de la plataforma para implementar
concurrencia.
• Todas las condiciones en Java deben tener como resultado un tipo

boleano. Dado que en Java los resultados de las expresiones son dados bajo
este tipo de dato. Mientras que en C y C++ se considera a un valor de cero
como falso y no cero como verdadero.
• Java no soporta el operador sizeof. Este operador permite en C y C++

obtener el tamaño de una estructura de datos. En Java esto no es necesario
ya que cada objeto “sabe” el espacio que ocupa en memoria.
• No tiene herencia múltiple. Java solo cuenta con herencia simple, con lo
que pierde ciertas capacidades de generalización que son subsanadas a
través del uso de interfaces. El equipo de desarrollo de Java explica que esto
simplifica el lenguaje y evita la ambigüedad natural generada por la
herencia múltiple.
• No tiene liberación de memoria explícita (delete y free() ). En Java no es

necesario liberar la memoria ocupada, ya que cuenta con un recolector de
basura7 responsable de ir liberando cada determinado tiempo los recursos de
memoria que ya no se estén ocupando.
Además:
• No contiene estructuras y uniones (struct y union).

• No contiene tipos de datos sin signo.
• No permite alias (typedef).
• No tiene conversión automática de tipos compatibles.
7
Garbage Collector.
- 52 -
Archivos .java y .class
En Java el código fuente se almacena en archivos con extensión .java,

mientras que el bytecode o código compilado se almacena en archivos .class. El
compilador de Java crea un archivo .class por cada declaración de clase que
encuentra en el archivo .java.
Un archivo de código fuente debe tener solo una clase principal, y esta debe
tener exactamente el mismo nombre que el del archivo .java. Por ejemplo, si
tengo una clase que se llama Alumno, el archivo de código fuente se llamará
Alumno.java. Al compilar, el archivo resultante será Alumno.class.
Programas generados con java
Existen dos tipos principales de programas en Java8:
Por un lado están las aplicaciones, las cuales son programas standalone,
escritos en Java y ejecutados por un intérprete del código de bytes desde la línea
de comandos del sistema.
Por otra parte, los Applets, que son pequeñas aplicaciones escritas en Java,
las cuales siguen un conjunto de convenciones que les permiten ejecutarse dentro
de un navegador. Estos applets siempre están incrustados en una página html.
En términos del código fuente las diferencias entre un applet y una

aplicación son:
• Una aplicación debe definir una clase que contenga el método main(),
que controla su ejecución. Un applet no usa el método main(); su
8
Se presenta la división clásica de los programas de Java, aunque existen algunas otras opciones no son
relevantes en este curso.
- 53 -
ejecución es controlado por varios métodos definidos en la clase

applet.
• Un applet, debe definir una clase derivada de la clase Applet.
El Java Developer’s Kit
La herramienta básica para empezar a desarrollar aplicaciones o applets en

Java es el JDK (Java Development Kit) o Kit de Desarrollo Java, que consiste,
básicamente, en un compilador y un intérprete (JVM9) para la línea de comandos.
No dispone de un entorno de desarrollo integrado (IDE), pero es suficiente para
aprender el lenguaje y desarrollar pequeñas aplicaciones.10
Los principales programas del Java Development Kit:
javac. Es el compilador en línea del JDK.
java. Es la máquina virtual para aplicaciones de Java.
appletviewer. Visor de applets de java.
Compilación
Utilizando el JDK, los programas se compilan desde el símbolo del sistema

con el compilador javac.
Ejemplo:
C:\MisProgramas> javac MiClase.java
9
Java Virtual Machine
10
Este kit de desarrollo es gratuito y puede obtenerse de la dirección proporcionada al final de este
documento. Aunque en este curso se usara Eclipse, el jdk debe estar instalado para poder usar Java en
Eclipse.
- 54 -
Normalmente se compila como se ha mostrado en el ejemplo anterior. Sin

embargo, el compilador proporciona diversas opciones a través de modificadores
que se agregan en la línea de comandos.
Sintaxis:
javac [opciones] <archivo1.java>
donde opciones puede ser:
-classpath <ruta> Indica donde buscar los archivos de clasede Java

-d <directorio> Indica el directorio destino para los archivos .class
-g Habilita la generación de tablas de depuración.
-nowarn Deshabilita los mensajes del compilador.
-O Optimiza el código, generando en línea los métodos
estáticos, finales y privados.
-verbose Indica cuál archivo fuente se esta compilando.

- 55 -
“Hola Mundo”
Para no ir en contra de la tradición al comenzar a utilizar un lenguaje, los

primeros ejemplos serán precisamente dos programas muy simples que lo único
que van a hacer es desplegar el mensaje “Hola Mundo”.
Hola mundo básico en Java
El primero es una aplicación que va a ser interpretado posteriormente por la

máquina virtual:
public class HolaMundo {

public static void main(String args[]) {
System.out.println("¡Hola, Mundo!");
}
}
Para los que han programado en C ó C++, notarán ya ciertas similitudes. Lo

importante aquí es que una aplicación siempre requiere de un método main, este
tiene un solo argumento (String args[ ]), a través del cual recibe información de
los argumentos de la línea de comandos, pero la diferencia con los lenguajes
C/C++ es que este método depende de una clase, en este caso la clase
HolaMundo. Este programa es compilado en al jdk11:
%javac HolaMundo.java
con lo que, si el programa no manda errores, se obtendrá el archivo

HolaMundo.class.
11
Se asume que el jdk se encuentra instalado y que el PATH tiene indicado el directorio bin del jdk para que
encuentre el programa javac. También es recomendable añadir nuestro directorio de programas de java a una
variable de ambiente llamada CLASSPATH.
- 56 -
En Eclipse, al grabar automáticamente el programa se compilara (si la

opcion Build Automatically esta activada). De hecho, algunos errores se van
notificando, si los hay, conforme se va escribiendo el codigo en el editor.
Hola mundo básico en C++
En C++ no estamos obligados a usar clases, por lo que un Hola mundo en

C++ - aunque no en objetos – podría quedar de la siguiente forma:
#include <iostream>
int main(){
cout << "Hola Mundo!" << endl;
return 0;
}
Hola mundo en un Java Applet
Regresando a Java, veamos ahora la contraparte de este programa, que es el

applet Hola, el cual difiere sustancialmente del programa pasado:
import java.applet.Applet;
import java.awt.Graphics;
import java.awt.Color;
public class Hola extends Applet {

public void paint(Graphics g) { // Java llama a paint
automáticamente
g.setColor(Color.red);
g.drawString("¡Hola, Mundo!", 0, 50);
}
}

- 57 -
Este programa tiene diferentes requerimientos a una aplicación. En principio

carece de un método main, y en su lugar cuenta con un método paint el cual es
llamado por el navegador que cargue la página que contenga al applet.
Otro aspecto interesante es el uso de la instrucción import. Las clases en

Java están organizadas en paquetes, y son similares a las librerías de C++ para
agrupar funciones. Puede utilizarse opcionalmente la instrucción import, o hacer
referencia a toda la ruta completa cada vez que se usa una clase:
java.util.Hashtable miTabla = new java.util.Hastable();
es equivalente a:
import java.util.Hashtable; //importar esta clase
...
Hashtable miTable = new Hashtable();
Existen algunas clases que no necesitan ser importadas, como la clase

System, estas son las que se encuentran dentro del paquete java.lang, pues son
importadas automáticamente para todo programa de Java.
También es posible importar todas las clases de un paquete mediante el uso

del *. Ejemplo:
import java.awt.*;
La compilación del applet se realiza de la misma forma que con la

aplicación. Una vez que se tiene el archivo de clase, en el jdk no es posible
todavía ejecutar nuestro applet. Hay que preparar un archivo html para que haga
referencia al applet. La creación del archivo html es no necesaria para ejecutar el
applet desde Eclipse.

- 58 -
Archivo HTML
Anteriormente se mencionó que un applet debe ser invocado desde una

página de html. Sólo es necesario agregar la etiqueta <APPPLET> para indicar el
archivo de bytecode del applet.
Ejemplo de etiqueta en html:
<APPLET CODE=“Hola.class” WIDTH=250 HEIGHT=300></APPLET>
donde es especificado el nombre de la clase y, el ancho y alto que va a

ocupar para desplegarse el applet dentro de la página html. La ubicación del
applet dependerá de la ubicación de la etiqueta dentro de la página.
Ejecución
Para ejecutar una aplicación usamos la máquina virtual proporcionada por el

jdk, proporcionando el nombre de la clase:
% java HolaMundo
Para la ejecución de un applet utilizamos el appletviewer, también

proporcionado por el jdk:
% appletviewer hola.html
La ejecución del applet desde Eclipse implica seleccionar la opcion de “Run

as…” y posteriormente “Java Applet” del menú o icono de ejecución, o del menú
contextual.
Un applet en realidad es construido para se ejecutado por un navegador. El

appletviewer es una versión reducida de un navegador que es utilizada para
probar los applets. Un vez que vean que su applet se ejecuta en el visor de applets
pruébenlo en su navegador Firefox ó Explorer.

- 59 -
Es recomendable que primero prueben los applets en el visor, ya que este

soporta la misma versión de Java del jdk que tengan instalado. Dependiendo de su
configuraron, los navegadores no siempre soportan la última versión de Java.
Hola mundo en Eclipse
Probar estos ejemplos en Eclipse debe crearse un proyecto en Java. Como en Java
no hay funciones independientes, los archivos que se añaden al proyecto son
archivos de clases. Al añadir una clase al proyecto aparece la siguiente ventana:
La información mínima necesaria es el nombre de la clase. La extensión del

archivo (.java) será colocada por Eclipse.

- 60 -
Fundamentos del Lenguaje Java
En esta sección se hablara de cómo está constituido el lenguaje, sus

instrucciones, tipos de datos, etc. Antes de comenzar a hacer programación
orientada a objetos.
Comentarios
Los comentarios en los programas fuente son muy importantes en cualquier

lenguaje. Sirven para aumentar la facilidad de comprensión del código y para
recordar ciertas cosas sobre el mismo. Son porciones del programa fuente que el
compilador omite, y, por tanto, no ocuparán espacio en el archivo de clase.
Existen tres tipos de comentarios en Java:
• Si el comentario que se desea escribir es de una sola línea, basta con poner
dos barras inclinadas //. Por ejemplo:
for (i=0; i<20;i++) // comentario de ciclo
{
System.out.println(“Adiós”);
}
No puede ponerse código después de un comentario introducido por // en la

misma línea, ya que desde la aparición de las dos barras inclinadas // hasta el final
de la línea es considerado como comentario e ignorado por el compilador.
• Si un comentario debe ocupar más de una línea, hay que anteponerle /* y al

final */. Por ejemplo:
/* Esto es un
comentario que
ocupa tres líneas */

- 61 -
• Existe otro tipo de comentario que sirve para generar documentación

automáticamente en formato HTML mediante la herramienta javadoc.
Puede ocupar varias líneas y se inicia con /** para terminar con */. Para
mas información ver: http://java.sun.com/j2se/javadoc/
Tipos de datos
En Java existen dos tipos principales de datos:
1. Tipos de datos simples.

2. Referencias a objetos.
Los tipos de datos simples son aquellos que pueden utilizarse directamente
en un programa, sin necesidad del uso de clases. Estos tipos son:
• byte
• short
• int
• long
• float
• double
• char
• boolean
El segundo tipo está formado por todos los demás. Se les llama referencias
porque en realidad lo que se almacena en los mismos son punteros a áreas de
memoria donde se encuentran almacenadas las estructuras de datos que los
soportan. Dentro de este grupo se encuentran las clases (objetos) y también se
incluyen las interfaces, los vectores y las cadenas o Strings.
Pueden realizarse conversiones entre los distintos tipos de datos (incluso

entre simples y referenciales), bien de forma implícita o de forma explícita.

- 62 -
Tipos de datos simples
Los tipos de datos simples en Java tienen las siguientes características:
TIPO Descripción Formato long. Rango

byte byte C-212 1 byte - 128 … 127
short entero corto C-2 2 - 32.768 … 32.767
bytes
int entero C-2 4 - 2.147.483.648
bytes …2.147.483.647
long entero largo C-2 8 -9.223.372.036.854.775.808
bytes …9.223.372.036.854.775.807
float real en coma IEEE 32 ±3,4*10-38… ±3,4*1038
flotante de 754 bits
precisión
simple
double real en coma IEEE 64 ±1,7*10-308… ±1,7*10308
flotante de 754 bits
precisión
doble
char Carácter Unicode 2 0 … 65.535
bytes
boolean Lógico 1 bit true / false
No existen más datos simples en Java. Incluso éstos que se enumeran

pueden ser remplazados por clases equivalentes (Integer, Double, Byte, etc.), con
la ventaja de que es posible tratarlos como si fueran objetos en lugar de datos
simples.
A diferencia de otros lenguajes de programación como C, en Java los tipos

de datos simples no dependen de la plataforma ni del sistema operativo. Un
12
C-2 = Complemento a dos.
- 63 -
entero de tipo int siempre tendrá 4 bytes, por lo que no tendremos resultados
inesperados al migrar un programa de un sistema operativo a otro.
Eso sí, Java no realiza una comprobación de los rangos. Por ejemplo: si a
una variable de tipo short con el valor 32.767 se le suma 1, el resultado será -
32.768 y no se producirá ningún error de ejecución.
Los valores que pueden asignarse a variables y que pueden ser utilizados en
expresiones directamente reciben el nombre de literales.
Referencias a objetos
El resto de tipos de datos que no son simples, son considerados referencias.

Estos tipos son básicamente apuntadores a las instancias de las clases, en las que
se basa la programación orientada a objetos.
Al declarar un objeto perteneciente a una determinada clase, se indica que

ese identificador de referencia tiene la capacidad de apuntar a un objeto del tipo al
que pertenece la variable. El momento en el que se realiza la reserva física del
espacio de memoria es cuando se instancia el objeto realizando la llamada a su
constructor, y no en el momento de la declaración.
Existe un tipo referencial especial nominado por la palabra reservada null

que puede ser asignado a cualquier variable de cualquier clase y que indica que el
puntero no tiene referencia a ninguna zona de memoria (el objeto no está
inicializado).
Identificadores
Los identificadores son los nombres que se les da a las variables, clases,
interfaces, atributos y métodos de un programa.
Existen algunas reglas básicas para nombrar a los identificadores:

- 64 -
1. Java hace distinción entre mayúsculas y minúsculas, por lo tanto, nombres o

identificadores como var1, Var1 y VAR1 son distintos.
2. Pueden estar formados por cualquiera de los caracteres del código Unicode,
por lo tanto, se pueden declarar variables con el nombre: añoDeCreación,
raïm, etc.
3. El primer carácter no puede ser un dígito numérico y no pueden utilizarse
espacios en blanco ni símbolos coincidentes con operadores.
4. No puede ser una palabra reservada del lenguaje ni los valores lógicos true
o false.
5. No pueden ser iguales a otro identificador declarado en el mismo ámbito.
6. Por convención, los nombres de las variables y los métodos deberían
empezar por una letra minúscula y los de las clases por mayúscula.
Además, si el identificador está formado por varias palabras, la primera se

escribe en minúsculas (excepto para las clases e interfaces) y el resto de palabras
se hace empezar por mayúscula (por ejemplo: añoDeCreación). Las constantes se
escriben en mayúsculas, por ejemplo MÁXIMO.
Esta última regla no es obligatoria, pero es conveniente ya que ayuda al

proceso de codificación de un programa, así como a su legibilidad. Es más
sencillo distinguir entre clases y métodos, variables o constantes.
Variables
La declaración de una variable se realiza de la misma forma que en C/C++.

Siempre contiene el nombre (identificador de la variable) y el tipo de dato al que
pertenece. El ámbito de la variable depende de la localización en el programa
donde es declarada.
Ejemplo:
int x;

- 65 -
Las variables pueden ser inicializadas en el momento de su declaración,

siempre que el valor que se les asigne coincida con el tipo de dato de la variable.
Ejemplo:
int x = 0;
Ámbito de una variable.
El ámbito de una variable es la porción de programa donde dicha variable es

visible para el código del programa y, por tanto, referenciable. El ámbito de una
variable depende del lugar del programa donde es declarada, pudiendo pertenecer
a cuatro categorías distintas.
• Variable local.
• Atributo.
• Parámetro de un método.
• Parámetro de un manejador de excepciones13.
Como puede observarse, no existen las variables globales. La utilización de

variables globales es considerada peligrosa, ya que podría ser modificada en
cualquier parte del programa y por cualquier procedimiento. A la hora de
utilizarlas hay que buscar dónde están declaradas para conocerlas y dónde son
modificadas para evitar sorpresas en los valores que pueden contener.
Los ámbitos de las variables u objetos en Java siguen los criterios

“clásicos”, al igual que en la mayoría de los lenguajes de programación como
Pascal, C++, etc.
Si una variable que no es local no ha sido inicializada, tiene un valor

asignado por defecto. Este valor es, para las variables referencias a objetos, el
valor null. Para las variables de tipo numérico, el valor por defecto es cero, las
variables de tipo char, el valor ‘\u0000’ y las variables de tipo boolean, el valor
false.
13
Este se tocará en otra etapa del curso, al hablar de manejo de excepciones.
- 66 -
Variables locales. Una variable local se declara dentro del cuerpo de un método
de una clase y es visible únicamente dentro de dicho método. Se puede declarar
en cualquier lugar del cuerpo, incluso después de instrucciones ejecutables,
aunque es una buena costumbre declararlas justo al principio.
Ejemplo:
class Caracter {
char ch;
public Caracter(char c) {
ch=c;
}
public void repetir(int num) {

int i;
for (i=0;i<num;i++)
System.out.println(ch);
}
}
public class Ej1 {

public static void main(String argumentos[]) {
Caracter caracter;
caracter = new Caracter('H');
caracter.repetir(20);
}
}
En este ejemplo existe una variable local: int i; definida en el método

repetir de la clase Caracter, por lo tanto, únicamente es visible dentro del método
repetir. También existe una variable local en el método main. En este caso, la
variable local es un objeto: Caracter caracter; que sólo será visible
dentro del método en el que está declarada (main).
Es importante hacer notar que una declaración como la anterior le indica al

compilador el tipo de la variable caracter pero no crea un objeto )la variable es
inicializada con el valor null). El operador que crea el objeto es new, que necesita
- 67 -
como único parámetro el nombre del constructor, que será el procedimiento que
asigna valor a ese objeto recién instanciado.
Cuando se pretende declarar múltiples variables del mismo tipo pueden

declararse, en forma de lista, separadas por comas:
Ejemplo:
int x,y,z; //Declara tres variables x, y, z de tipo entero.
Podrían haberse inicializado en su declaración de la forma:
int x=0,y=0,z=3;
No es necesario que se declaren al principio del método. Puede hacerse en

cualquier lugar del mismo, incluso de la siguiente forma:
void repetir(int num) {

for (int i=0;i<num;i++)
System.out.println(ch);
}
Las variables locales pueden ser antecedidas por la palabra reservada final.
En ese caso, sólo permiten que se les asigne un valor una única vez14.
Ejemplo:
final int x=0;
No permitirá que a x se le asigne ningún otro valor. Siempre contendrá 0.

No es necesario que el valor se le asigne en el momento de la declaración, podría
haberse asignado en cualquier otro lugar, pero una sola vez15.
14
final es utilizado para declarar algo similar a las constantes.
15
Esta posibilidad aparece por primera vez en la versión 1.1 del jdk.
- 68 -
Ejemplo:
final int x;
...
x=y+2;
Después de la asignación x=y+2, no se permitirá asignar ningún otro valor a

x.
Operadores
Los operadores son partes indispensables en la construcción de expresiones.

Existen muchas definiciones técnicas para el término expresión. Puede decirse
que una expresión es una combinación de operandos ligados mediante
operadores.
Los operandos pueden ser variables, constantes, funciones, literales, etc. y

los operadores se comentarán a continuación.
Operadores aritméticos:
Operador Formato Descripción

+ op1 + op2 Suma aritmética de dos operandos
- op1 - op2 Resta aritmética de dos operandos
-op1 Cambio de signo
* op1 * op2 Multiplicación de dos operandos
/ op1 / op2 División entera de dos operandos
% op1 % op2 Resto de la división entera ( o módulo)
++ ++op1
op1++ Incremento unitario
-- -- op1
op1-- Decremento unitario

- 69 -
El operador - puede utilizarse en su versión unaria ( - op1 ) y la operación

que realiza es la de invertir el signo del operando.
Como en C/C++, los operadores unarios ++ y -- realizan un incremento y un

decremento respectivamente. Estos operadores admiten notación prefija y
postfija.
• ++op1: En primer lugar realiza un incremento (en una unidad) de op1 y

después ejecuta la instrucción en la cual está inmerso.
• op1++: En primer lugar ejecuta la instrucción en la cual está inmerso y
después realiza un incremento (en una unidad) de op1.
• --op1: En primer lugar realiza un decremento (en una unidad) de op1 y
después ejecuta la instrucción en la cuál está inmerso. Visión General y
elementos básicos del lenguaje.
• op1--: En primer lugar ejecuta la instrucción en la cual está inmerso y
después realiza un decremento (en una unidad) de op1.
La diferencia entre la notación prefija y la postfija no tiene importancia en

expresiones en las que únicamente existe dicha operación:
++contador; //es equivalente a: contador++;
--contador; //contador--;
La diferencia es apreciable en instrucciones en las cuáles están incluidas

otras operaciones.
Ejemplo:
a = 1; a = 1;
b = 2 + a++; b = 2 + ++a;
En el primer caso, después de las operaciones, b tendrá el valor 3 y al valor

2. En el segundo caso, después de las operaciones, b tendrá el valor 4 y al valor 2.

- 70 -
Operadores relacionales:

> op1 > op2 Devuelve true si op1 es mayor que
op2
< op1 < op2 Devuelve true si op1 es menor que
op2
>= op1 >= op2 Devuelve true si op1 es mayor o
igual que op2
<= op1<= op2 Devuelve true si op1 es menor o
igual que op2
== op1 == op2 Devuelve true si op1 es igual a op2
!= op1 != op2 Devuelve true si op1 es distinto de
op2
Los operadores relacionales actúan sobre valores enteros, reales y

caracteres; y devuelven un valor del tipo boleano (true o false).
Ejemplo:
public class Relacional {
public static void main(String arg[]) {
double op1,op2;
op1=1.34;
op2=1.35;
System.out.println("op1="+op1+" op2="+op2);
System.out.println("op1>op2 = "+(op1>op2));
System.out.println("op1<op2 = "+(op1<op2));
System.out.println("op1==op2 = "+(op1==op2));
System.out.println("op1!=op2 = "+(op1!=op2));
char op3,op4;
op3='a'; op4='b';
System.out.println("'a'>'b' = "+(op3>op4));
}
}

- 71 -
Operadores lógicos:

&& op1 && op2 Y lógico. Devuelve true si son ciertos op1 y
op2
|| op1 || op2 O lógico. Devuelve true si son ciertos op1 o
op2
! ! op1 Negación lógica. Devuelve true si es falso
op1.
Estos operadores actúan sobre operadores o expresiones lógicas, es decir,

aquellos que se evalúan a cierto o falso.
Ejemplo:
public class Bool {
public static void main ( String argumentos[] ) {
boolean a=true;
boolean b=true;
boolean c=false;
boolean d=false;
System.out.println("true Y true = " + (a && b) );
System.out.println("true Y false = " + (a && c) );
System.out.println("false Y false = " + (c && d) );
System.out.println("true O true = " + (a || b) );
System.out.println("true O false = " + (a || c) );
System.out.println("false O false = " + (c || d) );
System.out.println("NO true = " + !a);
System.out.println("NO false = " + !c);
System.out.println("(3 > 4) Y true = " + ((3 >4) && a)
);
}
}

- 72 -
Operadores de bits:

>> op1 >> op2 Desplaza op1, op2 bits a la derecha
<< op1 << op2 Desplaza op1, op2 bits a la izquierda
>>> op1 >>> op2 Desplaza op1, op2 bits a la derecha (sin signo).
& op1 & op2 Realiza un Y (AND) a nivel de bits
| op1 | op2 Realiza un O (OR) a nivel de bits
^ op1 ^ op2 Realiza un O exclusivo (XOR) a nivel de bits
~ ~op1 Realiza el complemento de op1 a nivel de bits.
Los operadores de bits actúan sobre valores enteros (byte, short, int y long)
o caracteres (char).
Ejemplo:
public class Bits {
public static void main ( String argumentos[] ) {
byte a=12;
byte b=-12;
byte c=6;
System.out.println("12 >> 2 = " + (a >> 2) );
System.out.println("-12 >> 2 = " + (b >> 2) );
System.out.println("-12 >>> 2 = " + (b >>> 2) );
System.out.println("12 << 2 = " + (a << 2) );
System.out.println("-12 << 2 = " + (b << 2) );
System.out.println("12 & 6 = " + (a & c) );
System.out.println("12 | 6 = " + (a | c) );
System.out.println("12 ^ 6 = " + (a ^ c) );
System.out.println("~12 = " + ~a);
}
}
Los números negativos se almacenan en Complemento a dos (c-2), lo que

significa que para almacenar el número negativo se toma el positivo en binario, se
cambian unos por ceros y viceversa, y después se le suma 1 en binario.

- 73 -
Operadores de asignación:
El operador de asignación es el símbolo igual ( = ).
op1 = Expresión;
Asigna el resultado de evaluar la expresión de la derecha a op1.
Además del operador de asignación existen unas abreviaturas, como en

C/C++, cuando el operando que aparece a la izquierda del símbolo de asignación
también aparece a la derecha del mismo:
Operador Formato Equivalencia

+= op1 += op2 op1 = op1 + op2
-= op1 -= op2 op1 = op1 - op2
*= op1 *= op2 op1 = op1 * op2
/= op1 /= op2 op1 = op1 / op2
%= op1 %= op2 op1 = op1 % op2
&= op1 &= op2 op1 = op1 & op2
|= op1 |= op2 op1 = op1 | op2
^= op1 ^= op2 op1 = op1 ^ op2
>>= op1 >>= op2 op1 = op1 >> op2
<<= op1 <<= op2 op1 = op1 << op2
>>>= op1 >>>= op2 op1 = op1 >>> op2
Precedencia de operadores en Java
La precedencia indica el orden en que es resuelta una expresión, la siguiente

lista muestra primero los operadores de mayor precedencia.
Operadores postfijos [] . (paréntesis)

Operadores unarios ++expr --expr -expr ~ !
Creación o conversión de tipo new (tipo)expr
Multiplicación y división * / %

- 74 -
Suma y resta + -
Desplazamiento de bits << >> >>>
Relacionales < > <= >=
Igualdad y desigualdad == !=
AND a nivel de bits &
XOR a nivel de bits ^
OR a nivel de bits |
AND lógico &&
OR lógico ||
Condicional terciaria ? :
Asignación = += -= *= /= %= ^= &= |= >>= <<=
>>>=
Valores literales
A la hora de tratar con valores de los tipos de datos simples (y Strings) se

utiliza lo que se denomina “literales”. Los literales son elementos que sirven para
representar un valor en el código fuente del programa.
En Java existen literales para los siguientes tipos de datos:
• Lógicos (boolean).
• Carácter (char).
• Enteros (byte, short, int y long).
• Reales (double y float).
• Cadenas de caracteres (String).
Literales lógicos
Son únicamente dos: las palabras reservadas true y false.

- 75 -
Ejemplo:
boolean activado = false;
Literales de tipo entero
Son byte, short, int y long pueden expresarse en decimal (base 10), octal
(base 8) o hexadecimal (base 16). Además, puede añadirse al final del mismo la
letra L para indicar que el entero es considerado como long (64 bits).
Literales de tipo real
Los literales de tipo real sirven para indicar valores float o double. A
diferencia de los literales de tipo entero, no pueden expresarse en octal o
hexadecimal.
Existen dos formatos de representación: mediante su parte entera, el punto

decimal ( . ) y la parte fraccionaria; o mediante notación exponencial o científica:
Ejemplos equivalentes:
3.1415
0.31415e1
.31415e1
0.031415E+2
.031415e2
314.15e-2
31415E-4
Al igual que los literales que representan enteros, se puede poner una letra
como sufijo. Esta letra puede ser una F o una D (mayúscula o minúscula
indistintamente).
• F Trata el literal como de tipo float.

• D Trata el literal como de tipo double.
- 76 -
Ejemplo:
3.1415F
.031415d
Literales de tipo carácter
Los literales de tipo carácter se representan siempre entre comillas simples.

Entre las comillas simples puede aparecer:
• Un símbolo (letra) siempre que el carácter esté asociado a un código

Unicode. Ejemplos: ‘a’ , ‘B’ , ‘{‘ , ‘ñ’ , ‘á’ .
• Una “secuencia de escape”. Las secuencias de escape son combinaciones

del símbolo \ seguido de una letra, y sirven para representar caracteres que
no tienen una equivalencia en forma de símbolo.
Las posibles secuencias de escape son:
Secuencia de escape Significado

’\’’ Comilla simple.
’\”’ Comillas dobles.
’\\’ Barra invertida.
’\b’ Backspace (Borrar hacia atrás).
’\n’ Cambio de línea.
’\f’ Form feed.
’\r’ Retorno de carro.
’\t’ Tabulador.

- 77 -
Literales de tipo String
Los Strings o cadenas de caracteres no forman parte de los tipos de datos

elementales en Java, sino que son instanciados a partir de la clase
java.lang.String, pero aceptan su inicialización a partir de literales de este tipo.
Un literal de tipo String va encerrado entre comillas dobles ( “ ) y debe estar

incluido completamente en una sola línea del programa fuente (no puede dividirse
en varias líneas). Entre las comillas dobles puede incluirse cualquier carácter del
código Unicode (o su código precedido del carácter \ ) además de las secuencias
de escape vistas anteriormente en los literales de tipo carácter. Así, por ejemplo,
para incluir un cambio de línea dentro de un literal de tipo String deberá hacerse
mediante la secuencia de escape \n :
Ejemplo:
System.out.println("Primera línea \n Segunda línea del
string\n");
System.out.println("Hol\u0061");
La visualización del String anterior mediante println() produciría la siguiente

salida por pantalla:
Primera línea
Segunda línea del string
Hola
La forma de incluir los caracteres: comillas dobles ( “ ) y barra invertida ( \ )

es mediante las secuencias de escape \” y \\ respectivamente (o mediante su
código Unicode precedido de \ ).
Si la cadena es demasiado larga y debe dividirse en varias líneas en el

código fuente, o simplemente concatenar varias cadenas, puede utilizarse el
operador de concatenación de strings + .de la siguiente forma:

- 78 -
“Este String es demasiado largo para estar en una línea” +

“del código fuente y se ha dividido en dos.”
Estructuras de control
Las estructuras de control son construcciones definidas a partir de palabras

reservadas del lenguaje que permiten modificar el flujo de ejecución de un
programa. De este modo, pueden crearse construcciones de decisión y ciclos de
repetición de bloques de instrucciones.
Hay que señalar que, como en C/C++, un bloque de instrucciones se

encontrará encerrado mediante llaves {……..} si existe más de una instrucción.
Estructuras condicionales
Las estructuras condicionales o de decisión son construcciones que permiten

alterar el flujo secuencial de un programa, de forma que en función de una
condición o el valor de una expresión, el mismo pueda ser desviado en una u otra
alternativa de código.
Las estructuras condicionales disponibles en Java son:
• Estructura if-else.
• Estructura switch.
if-else
Forma simple:
if (<expresión>)
<Bloque instrucciones>
El bloque de instrucciones se ejecuta si, y sólo si, la expresión (que debe ser
lógica) se evalúa a verdadero, es decir, se cumple una determinada condición.
- 79 -
Ejemplo:
if (cont == 0)
System.out.println("he llegado a cero");
La instrucción System.out.println(“he llegado a cero”); sólo se

ejecuta en el caso de que cont contenga el valor cero.
Forma bicondicional:
if (<expresión>)
<Bloque instrucciones 1>
else
<Bloque instrucciones 2>
El bloque de instrucciones 1 se ejecuta si, y sólo si, la expresión se evalúa

como verdadero. Y en caso contrario, si la expresión se evalúa como falso, se
ejecuta el bloque de instrucciones 2.
Ejemplo:
if (cont == 0)
System.out.println("he llegado a cero");
else
System.out.println("no he llegado a cero");
En Java, como en C/C++ y a diferencia de otros lenguajes de programación,

en el caso de que el bloque de instrucciones conste de una sola instrucción no
necesita ser encerrado en un bloque.
switch
Sintaxis:
switch (<expresión>) {
case <valor1>: <instrucciones1>;
- 80 -

...
case <valorN>: <instruccionesN>;
}
En este caso, a diferencia del if, si <instrucciones1>, <instrucciones2> ó

<instruccionesN> están formados por un bloque de instrucciones sencillas, no es
necesario encerrarlas mediante las llaves ( { … } ).
En primer lugar se evalúa la expresión cuyo resultado puede ser un valor de

cualquier tipo. El programa comprueba el primer valor (valor1). En el caso de que
el valor resultado de la expresión coincida con valor1, se ejecutará el bloque
<instrucciones1>. Pero también se ejecutarían el bloque <instrucciones2> …
<instruccionesN> hasta encontrarse con la palabra reservada break. Por lo que
comúnmente se añade una instrucción break al final de cada caso del switch.
Ejemplo:
switch (<expresión>) {

break;
break;
...
case <valorN>: <instruccionesN>;
}
Si el resultado de la expresión no coincide con <valor1>, evidentemente no

se ejecutarían <instrucciones1>, se comprobaría la coincidencia con <valor2> y
así sucesivamente hasta encontrar un valor que coincida o llegar al final de la
construcción switch. En caso de que no exista ningún valor que coincida con el de
la expresión, no se ejecuta ninguna acción.

- 81 -
Ejemplo:
public class DiaSemana {

int dia;
if (argumentos.length<1) {
System.out.println("Uso: DiaSemana num");
System.out.println("Donde num = nº entre 1 y 7");
}
else {
dia=Integer.valueOf(argumentos[0]).intValue();
switch (dia) {
case 1: System.out.println("Lunes");
break;
case 2: System.out.println("Martes");
break;
case 3: System.out.println("Miércoles");
break;
case 4: System.out.println("Jueves");
break;
case 5: System.out.println("Viernes");
break;
case 6: System.out.println("Sábado");
break;
case 7: System.out.println("Domingo");
}
}
}
}
Nótese que en el caso de que se introduzca un valor no comprendido entre 1 y 7,

no se realizará ninguna acción. Esto puede corregirse agregando la opción por
omisión:
default: instruccionesPorDefecto;
donde la palabra reservada default, sustituye a case <expr> para ejecutar el

conjunto de instrucciones definido en caso de que no coincida con ningún otro
caso.
- 82 -
Ciclos.
Los ciclos o iteraciones son estructuras de repetición. Bloques de

instrucciones que se repiten un número de veces mientras se cumpla una
condición o hasta que se cumpla una condición.
Existen tres construcciones para estas estructuras de repetición:
• Ciclo for.
• Ciclo do-while.
• Ciclo while.
Como regla general puede decirse que se utilizará el ciclo for cuando se
conozca de antemano el número exacto de veces que ha de repetirse un
determinado bloque de instrucciones. Se utilizará el ciclo do-while cuando no se
conoce exactamente el número de veces que se ejecutará el ciclo pero se sabe que
por lo menos se ha de ejecutar una. Se utilizará el ciclo while cuando es posible
que no deba ejecutarse ninguna vez. Con mayor o menor esfuerzo, puede
utilizarse cualquiera de ellas indistintamente.
Ciclo for.
Sintaxis:
for (<inicialización> ; <condición> ; <incremento>)

<bloque instrucciones>
• La cláusula inicialización es una instrucción que se ejecuta una sola vez al

inicio del ciclo, normalmente para inicializar un contador.
• La cláusula condición es una expresión lógica, que se evalúa al inicio de
cada nueva iteración del ciclo. En el momento en que dicha expresión se
evalúe a falso, se dejará de ejecutar el ciclo y el control del programa pasará
a la siguiente instrucción (a continuación del ciclo for).

- 83 -
• La cláusula incremento es una instrucción que se ejecuta en cada iteración

del ciclo como si fuera la última instrucción dentro del bloque de
instrucciones. Generalmente se trata de una instrucción de incremento o
decremento de alguna variable.
Cualquiera de estas tres cláusulas puede estar vacía, aunque siempre hay que
poner los puntos y coma ( ; ).
El siguiente programa muestra en pantalla la serie de Fibonacci hasta el

término que se indique al programa como argumento en la línea de comandos.
Siempre se mostrarán, por lo menos, los dos primeros términos
Ejemplo:
// siempre se mostrarán, por lo menos, los dos primeros
//términos
public class Fibonacci {
int numTerm,v1=1,v2=1,aux,cont;
System.out.println("Uso: Fibonacci num");
System.out.println("Donde num = nº de términos");
}
else {
numTerm=Integer.valueOf(argumentos[0]).intValue();
System.out.print("1,1");
for (cont=2;cont<numTerm;cont++) {
aux=v2;
v2+=v1;
v1=aux;
System.out.print(","+v2);
}
System.out.println();
}
}
}

- 84 -
Ciclo do-while.
Sintaxis:
do
while (<Expresión>);
En este tipo de ciclo, el bloque instrucciones se ejecuta siempre una vez por
lo menos, y el bloque de instrucciones se ejecutará mientras <Expresión> se
evalúe como verdadero. Por lo tanto, entre las instrucciones que se repiten deberá
existir alguna que, en algún momento, haga que la expresión se evalúe como
falso, de lo contrario el ciclo sería infinito.
Ejemplo:
//El mismo que antes (Fibonacci).

class Fibonacci2 {
int numTerm,v1=0,v2=1,aux,cont=1;
}
else {
System.out.print("1");
do {
aux=v2;
v2+=v1;
v1=aux;
} while (++cont<numTerm);
}
}
}

- 85 -
En este caso únicamente se muestra el primer término de la serie antes de

iniciar el ciclo, ya que el segundo siempre se mostrará, porque el ciclo do-while
siempre se ejecuta una vez por lo menos.
Ciclo while.
Sintaxis:
while (<Expresión>)
Al igual que en el ciclo do-while del apartado anterior, el bloque de

instrucciones se ejecuta mientras se cumple una condición (mientras Expresión se
evalúe verdadero), pero en este caso, la condición se comprueba antes de empezar
a ejecutar por primera vez el ciclo, por lo que si Expresión se evalúa como falso
en la primera iteración, entonces el bloque de instrucciones no se ejecutará
ninguna vez.
Ejemplo:
//Fibonacci:
class Fibonacci3 {
int numTerm,v1=1,v2=1,aux,cont=2;
}
else {
System.out.print("1,1");
while (cont++<numTerm) {
aux=v2;
v2+=v1;
v1=aux;

- 86 -
}
}
}
}
Como puede comprobarse, las tres construcciones de ciclo (for, do-while y

while) pueden utilizarse indistintamente realizando unas pequeñas variaciones en
el programa.
Saltos
En Java existen dos formas de realizar un salto incondicional en el flujo

normal de un programa: las instrucciones break y continue.
break. La instrucción break sirve para abandonar una estructura de control, tanto
de las alternativas (if-else y switch) como de las repetitivas o ciclos (for, do-while
y while). En el momento que se ejecuta la instrucción break, el control del
programa sale de la estructura en la que se encuentra.
Ejemplo:
class Break {
int i;
for (i=1; i<=4; i++) {
if (i==3)
break;
System.out.println("Iteracion: "+i);
}
}
}
Aunque el ciclo, en principio indica que se ejecute 4 veces, en la tercera

iteración, i contiene el valor 3, se cumple la condición de i==3 y por lo tanto se
ejecuta el break y se sale del ciclo for.

- 87 -
continue. La instrucción continue sirve para transferir el control del programa

desde la instrucción continue directamente a la cabecera del ciclo (for, do-while o
while) donde se encuentra.
Ejemplo:
public class Continue {

int i;
for (i=1; i<=4; i++) {
if (i==3)
continue;
System.out.println("Itereación: "+i);
}
}
}
Puede comprobarse la diferencia con respecto al resultado del ejemplo del

apartado anterior. En este caso no se abandona el ciclo, sino que se transfiere el
control a la cabecera del ciclo donde se continúa con la siguiente iteración.
Tanto el salto break como en el salto continue, pueden ser evitados

mediante distintas construcciones pero en ocasiones esto puede empeorar la
legibilidad del código. De todas formas existen programadores que no aceptan
este tipo de saltos y no los utilizan en ningún caso; la razón es que - se dice - que
atenta contra las normas de las estructuras de control.
Arreglos
Para manejar colecciones de objetos del mismo tipo estructurados en una

sola variable se utilizan los arreglos.
En Java, los arreglos son en realidad objetos y por lo tanto se puede llamar a
sus métodos. Existen dos formas equivalentes de declarar arreglos en Java:

- 88 -
tipo nombreDelArreglo[ ];
ó
tipo[ ] nombreDelArreglo;
Ejemplo:
int arreglo1[], arreglo2[], entero; //entero no es un arreglo
int[] otroArreglo;
También pueden utilizarse arreglos de más de una dimensión:
Ejemplo:
int matriz[][];
int [][] otraMatriz;
Los arreglos, al igual que las demás variables pueden ser inicializados en el
momento de su declaración. En este caso, no es necesario especificar el número
de elementos máximo reservado. Se reserva el espacio justo para almacenar los
elementos añadidos en la declaración.
Ejemplo:
String Días[]={"Lunes","Martes","Miércoles","Jueves",
"Viernes","Sábado","Domingo"};
Una simple declaración de un vector no reserva espacio en memoria, a

excepción del caso anterior, en el que sus elementos obtienen la memoria
necesaria para ser almacenados. Para reservar la memoria hay que llamar
explícitamente a new de la siguiente forma:
new tipoElemento[ <numElementos> ];
Ejemplo:
int matriz[][];
matriz = new int[4][7];
- 89 -
También se puede indicar el número de elementos durante su declaración:
Ejemplo:
int vector[] = new int[5];
Para hacer referencia a los elementos particulares del arreglo, se utiliza el

identificador del arreglo junto con el índice del elemento entre corchetes. El
índice del primer elemento es el cero y el del último, el número de elementos
menos uno.
Ejemplo:
j = vector[0]; vector[4] = matriz[2][3];
El intento de acceder a un elemento fuera del rango del arreglo, a diferencia

de lo que ocurre en C, provoca una excepción (error) que, de no ser manejado por
el programa, será la máquina virtual quien aborte la operación.
Para obtener el número de elementos de un arreglo en tiempo de ejecución

se accede al atributo de la clase llamado length. No olvidemos que los arreglos en
Java son tratados como un objeto.
Ejemplo:
class Array1 {
public static void main (String argumentos[]) {
String colores[] = {"Rojo","Verde","Azul",
"Amarillo","Negro"};
int i;
for (i=0;i<colores.length;i++)
System.out.println(colores[i]);
}
}

- 90 -
Usando Java 5.0 (jdk 1.5) podemos simplificar el recorrido del arreglo:
public class Meses {
public static void main(String[] args) {

String meses[] =
{"Enero", "Febrero", "Marzo", "Abril", "Mayo",
"Junio", "Julio", "Agosto", "Septiembre", "Octubre",
"Noviembre", "Diciembre"};
//for(int i = 0; i < meses.length; i++ )

// System.out.println("mes: " + meses[i]);
// sintaxis para recorrer el arreglo y asignar

// el siguiente elemento a la variable mes en cada
ciclo
// instruccion "for each" a partir de version 5.0 (1.5
del jdk)
for(String mes: meses)
System.out.println("mes: " + mes);
Con Eclipse, aparte de contar al menos con el jdk 1.5, la opción de compilación
debe estar ajustada para que revise que el código sea compatible con esa versión:

- 91 -
Enumeraciones
Java desde la versión 5 incluye el manejo de enumeraciones. Las enumeraciones

sirven para agrupar un conjunto de elementos dentro de un tipo definido. Antes,
una manera simple de definir un conjunto de elementos como si fuera una
enumeración era, por ejemplo:
public static final int TEMPO_PRIMAVERA = 0;

public static final int TEMPO_VERANO = 1;
public static final int TEMPO_OTOÑO = 2;
public static final int TEMPO_INVIERNO = 3;
Lo cual puede ser problemático pues no es realmente un tipo de dato, sino un

conjunto de constantes enteras. Tampoco tienen un espacio de nombres definido
por lo que tienen que definirse nombre. La impresión de estos datos, puesto que
son enteros, despliega solo el valor numérico a menos que sea interpretado
explícitamente por código adicional en el programa.
El manejo de enumeraciones en Java tiene la sintaxis de C, C++ y C# :

enum <nombreEnum> { <elem 1>, <elem 2>, …, <elem n> }
Por lo que para el código anterior, la enumeración sería:
enum Temporada { PRIMAVERA, VERANO, OTOÑO, INVIERNO }
La sintaxis completa de enum es más compleja, ya que una enumeración en Java

es realmente una clase, por lo que puede tener métodos en su definición. También
es posible declarar la enumeración como pública, en cuyo caso debería ser
declarada en su propio archivo.

- 92 -
Ejemplo:
enum Temporada { PRIMAVERA, VERANO, OTOÑO, INVIERNO }
public class EnumEj {

Temporada tem;
tem=Temporada.PRIMAVERA;
System.out.println("Temporada: " + tem);
System.out.println("\nListado de temporadas:");
for(Temporada t: Temporada.values())
System.out.println("Temporada: " + t);
}
}

- 93 -
Introducción a Ruby
Ruby es un lenguaje definido para ser dinámico, reflectivo y orientado a objetos.

Combina una sintaxis inspirada en Perl y similar a las caracterísitcas orientadas a
objetos de Smalltalk. También comparte ciertas características con Phyton, Lisp,
Dylan, y CLU.
Ruby fue creado por Yukihiro Matsumoto con la idea de

crear un lenguaje que balanceara la programación funcional
con la programación imperativa.
El lenguaje fue liberado desde un inicio como open source

(1995) y en los últimos años ha crecido su aceptación
masivamente.
Matsumoto dice haber puesto énfasis en crear un lenguaje

productivo y divertido, siguiendo los principios de buen
diseó de interfaz con el usuario. Remarka que el diseño de
sistemas necesita –también- enfatizar las necesidades
humanas, en lugar de las de la computadora.
Ruby es actualmente un lenguaje interpretado aunque se pretende que a partir de

la versión 1.9 sea semi-compilado y ejecutado por una máquina virtual, de
manera similar a Java.
Características
Ruby es principalmente un lenguaje orientado a objetos, pero también

es descrito como un lenguaje multiparadigma: permite programación
procedural, con orientación a objetos y declaraciones funcionales.

- 94 -
Un resumen de sus características puede verse enseguida:

• Orientado a objetos
• 4 niveles de alcance de variables: global, clase, instancia y local
• Manejo de exepciones
• Expresiones regulares nativas al nivel del lenguaje (perl-like)
• Sobrecarga de operadores
• Recolector automático de basura
• Biblioteca dinámica compartida en la mayoría de las plataformas
• Soporta introspección, reflexión y metaprogramación
• Soporta continuations y generators
Comparado con C
Similitudes
• Puedes programar proceduralmente si lo deseas, pero aún sera orientado a
objetos internamente.
• La mayoría de los operadores son los mismos. Pero no cuenta con ++ o --.
• Se pueden tener constantes, aunque no hay una instrucción const.
• Las cadenas van entre comillas y son mutables.
• Se cuenta con un depurador en línea.
Diferencias
• Los objetos tienen un tipo fuerte y las variables no tienen tipo.
• No cuenta con macros o preprocesador.
• No tiene enmascaramiento.
• No tiene apuntadores, ni aritmética de apuntadores.
• No tiene tupedef, sizeof, ni enumeraciones.
• No archivos de encabezados.
• No maneja #define. Pero puedas usar constantes.
• Es interpretado en tiempo de ejecución, por lo que no hay código compilado
o byt-code de ningún tipo.
• Cuenta con recolector de basura.
• Los argumentos son pasados por referencia, no por valor.
• No usa ‘;’ obligatoriamente para finalizar instrucciones

- 95 -
• Condiciones para if y while van sin paréntesis.

• Paréntesis para llamadas a métodos son frecuentemente opcionales.
• Usualmente no se usan llaves. Usualmente se finalizan las instrucciones de
multiples líneas con una palabra clave.
• No hay declaraciones de variables. Asignas nombre conforme los necesitas.
• Sólo falso y nulo evaluan como falso. Cualquier otro valor es verdadero
(incluyendo 0 –cero-)
• No hay tipo char.
• Cadenas no terminan con un valor nulo.
• Los arreglos automáticamente se agrandan conforme vas necesitando más
elementos.
Comparado con C++
Similitudes
• Public, protected y private realizan actividades similares.
• Puedes poner tu código en módulos, similar a espacios de nombre en C++.
• Excepciones trabajan de forma similar.
Diferencias
• No hay referencias explícitas. En Ruby cada variable es un nombre
automáticamente desreferenciado para un objeto.
• El constructor es llamado initialize en lugar de usar el nombre de la clase.
• Todos los métodos son siempre virtuales.
• Nombres de atributos de clase siempre empiezan con @@.
• No es possible acceder directamente variables miembros. Todos los
atributos deben ser accedidos a mediante métodos.
• Se usa self en lugar de this.
• Algunos métodos terminan con ‘?’ o ‘!’. Es parte del nombre del método.
• No hay herencia multiple.
• Existen algunas convenciones forzadas (e.g.; nombre de clases empiezan
con mayúscula, variables inician con minuscula.)
• Solo dos tipos de clases contenedoras: Array y Hash.
• No hay conversiones de tipos automáticas.

- 96 -
• Multihilos son implementados en el interprete (green threads). No son hilos

nativos.
• Existe una biblioteca para pruebas de unidad como parte estándar del
lenguaje.
Comparado con Java
Similitudes
• La memoria es manejada automáticamente mediante un recolector de
basura.
• Los objetos son fuertemente tipados.
• Hay métodos públicos, privados y protegidos.
• Tiene herramientas de documentación embebidas (la de Ruby se llama
RDoc). La documentación generada por rdoc se ve muy similar a la
generada por javadoc.
Diferencias
• No necesitas compilar tu código fuente. Directamente lo ejecutas.
• Hay distintos conjuntos de herramientas para interfaz gráfica
• Se usa la palabra clave end después de definir clases, en vez de tener que
poner llaves encerrando el código.
• Tienes require en vez de import.
• Todas las variables de instancia son privadas. Desde afuera, todo se accede
usando métodos.
• Los paréntesis en las llamadas a los métodos usualmente son opcionales y a
menudo son omitidos.
• Todo es un objeto, incluyendo los números como 2 y 3,14159.
• No hay validación estática de tipos de datos.
• Los nombres de variables son sólo etiquetas. No tienen un tipo de dato
asociado.
• No hay declaración de tipo de datos. Simplemente se asigna a nuevos
nombres de variable a medida que se necesita (por ejemplo a = [1,2,3] en
vez de int[] a = {1,2,3};).

- 97 -
• No hay transformación de tipos (casting). Simplemente se llama a los

métodos. Tus pruebas unitarias deberían avisarte antes de que ejecutes el
código si habrá una excepción.
• Es foo = Foo.new("hola") en vez de Foo foo = new Foo("hola").
• El constructor siempre se llama “initialize” en vez del nombre de la clase.
• Tienes “mixins” en vez de interfaces.
• Se tiende a favorecer el uso de YAML en vez de XML.
• Es nil en vez de null.
Herramientas
Existen dos herramientas básicas en Ruby:
• ruby. Es el interprete del lenguaje. Puede recibir expresiones del lenguaje

como parámetros o archivos con programas:
• irb (o fxri en Windows). Este es Ruby interactivo (Interactive RuBy) que
permite recibir expresiones del lenguaje e irlas interpretando linea por linea,
como cualquier lenguaje interpretado.
Además:
• ri. Documentación de clases estándar de ruby.
También es posible integrar al interprete al IDE de Eclipse. Para esto se debe

agregar el plugin llamado Ruby Development Tools (RDT) aparte de tener
instalado el interprete en la computadora. El plugin puede ser encontrado en:
http://rubyeclipse.sourceforge.net/. Tiene que agregarse, como cualquier otro
plugin en la herramienta, mediante la opción de actualización del software en el
menu de ayuda de Eclipse.
El plugin debe configurarse indicando la ubicación del intérprete:

- 98 -
Ruby: Fundamentos del lenguaje

Convenciones léxicas
Espacios en blanco
Mientras una expresión del tipo a + b es interpretada como a+b, donde a es

una variable. El resultado puede ser diferente en casos ambiguos. Por ejemplo, si
a es el nombre de una función, entonces una expresión:
a +b
es interpretada como:
a (+b)
- 99 -
Final de instrucciones
Ruby interpreta ‘;’ y el espacio en blanco como el final de una instrucción.

Debido a esto, Ruby interpreta los símbolos ‘+’, ‘-‘ y ‘\’ como contianuación de
una instrucción.
Comentarios
Comentarios en Ruby son representados con #
# Este es un comentario
Comentarios de más de una línea usan =begin y =end, los cuales deben estar al
comienzo de una línea:
=begin
Este es un comentatio
=end
Identificadores
Cualquier nombre de constante, variables y métodos usado como identificador es

distinguido por Ruby si usa minúsculas o mayúsculas.
Literales
Enteros
Los números enteros son instancias de la clase Fixnum o Bignum.
123 # decimal
0377 # octal

- 100 -
0xff # hexadecimal
0b1011 # binary
?a # código para 'a'
12345678901234567890 # Bignum: entero de longitud
infinita
Flotantes
Los números de punto flotante son instancias de la clase Float.
123.4
1.0e6 # notación científica
4e+20 # exponencial
Cadenas
Una cadena es un arreglo de bytes y una instancia de la clase String:
“una cadena” # permite sustitución y notación con \
‘otra cadena’ # no permite sustitución y solo \ \ ó \’.
Concatenación.
Cadenas adyacentes son concatenadas :

“una” “cadena” # es igual a “una cadena”
Variables
En Ruby existen 5 tipos de variables, usando caracteres especiales para

diferenciar entre los distintos tipos de variables, lo que ayuda a identificar el tipo
de variable visualmente:
• Variable global
- 101 -
• Variable de instancia
• Variable de clase
• Variable local
• Constante
y además:
• Pseudo-variable
Variable global
Visibles a través de todo el programa y deben iniciar con el símbolo $, por

ejemplo:
$soyGlobal
Una variable global no inicializada tiene el valor de nil. Existen además

variables globales predefinidas que contienen información sobre el programa en
ejecución.
Variable de instancia
Las variables de instancia pertenecen a un objeto y son lo que también es

conocido en objetos como atributos. Estas son visibles dentro de un objeto en
particular y deben comenzar con @, por ejemplo:
@soyVariableDeInstancia
Al igual que las variables globales, estas tienen el valor de nil si no han sido
inicializadas.
Variable de clase
Las variables de clase son visibles, como su nombre lo dice, en la clase y

para todos los objetos de la misma. Comienzan con @@, por ejemplo:
- 102 -
@@variableDeClase
Estas variables deben ser inicializadas antes de que puedan ser usadas en los
métodos. El uso de una variable de clase no inicializada produce un error.
Ademas, estas clases son compartidas por descendientes de las clases donde
fueron definidas.
Variable local
Son válidas dentro del ambito local definido y deben empezar con una
minúscula o con el símbolo _. El ámbito puede ser el que defina una clase,
módulo, definición, do –end.
Constante
Deben empezar con una letra mayúscula y pueden ser definidas dentro de
una clase o módulo y serán visibles dentro de ese ámbito. Una constante
definida fuera de un clase o módulo será vista globalmente. Es posible reasignar
un valor a una constante, pero esto producirá una advertencia (pero no un error).
Pseudo-variable
Pseudo-variables tienen la apariencia de variables locales pero su

comportamiento es el de constantes. Ejemplo de estas vriables son self, true,
false, nil.
Operadores
Asignación
La asignación funcion con el operador =. Asignar variables locales también sirve

como declaración de la variable. La viariable existe hasta el final del alcance
donde la variable es declarada.
- 103 -
También se cuenta con asignación abreviada como en los lenguajes C/C++ y

Java:
+= -= *= /= %= **= <<= >>= &= |= ^= &&= ||=
Asignación paralela
destino[, destino...][, *destino] = expr[, expr...][, *expr]
Identificadores destino recibenla asignación de la correspondiente expresión en el

lado derecho. Si el último destino (lado izquierdo) tiene como prefijo un *, el
resto de los valores en el lado derecho se asigna en ese destino como un arreglo.
Si el * esta en el último elemento del lado derecho, el conjunto de elementos son
expandidos antes de su asignación.
Operadores lógicos
&& ó and. Regresa true si ambos operandos son verdaderos. Si el operando

izquierdo es falso, regresa ese valor, en caso contrario regresa el valor del
operando derecho.
|| ó or. Regresa true si cualquiera de los operandos es verdadero. Si el valor del

opreando izquierdo es true, regresa el valor de ese operando, de otro modo
regresa el valor del operando derecho.
Un aspecto interesante aquí es que los operadores and y or tienen una precedencia
muy baja, de hecho tienen la menor de las precedencias entre los operadores.
Operador ternario
El operador ternario ?: es el operador condicional similar al de C/C++ y Java.
a? b : c
- 104 -
Operador defined?
Este es un operador que puede determinar si una expressión esta definida.

Regresa una descripción de la expresión, o nulo si la expresión no esta definida.
defined? variable
Por ejemplo:
defined? a
defined? $_
Puede ser usado para verificar una llamada a un método, opcionalmente

incluyendo sus argumentos.
Prioridad de operadores
A continuación se presenta los operadores más comunes de Ruby en orden de

precedencia, de mayor a menor:
::
[]
**
+(unario) -(unario)
*/%
+-
<< >>
&
|^
> >= < <=
<=> == !=
&&
||
- 105 -
?:
= (y operadores abreviados como +=, -=, etc.)
not
and or
Operadores que no pueden ser redefinidos
Los siguientes operadores no pueden ser redefinidos :
...
!
not
&&
and
||
or
::
=
+=, -=, (y el resto de las asignaciones abreviadas)
?:
Arreglos
Un arreglo en Ruby es una clase contenedora que contiene una colección de

objetos. Cualquier tipo de objetos pueden ser almacenados en un arreglo,
inclusive pudiendo contener elementos de distinto tipo en un mismo arreglo. Otra
característica es que el arreglo aumenta de tamaño conforme se añaden elementos.
Un arreglo es representado con sus elementos entre corchetes [ ] :
[] Arreglo vacío
[1, 2, 3] Arreglo de 3 elementos

- 106 -
Los arreglos pueden ser asignados:
ar1= []
ar2= [1, 2, 3] # => [1, 2, 3]
Un arreglo puede añadir fácilmente un elemento mediante el operador <<. Ruby

dinámicamente ajusta el tamaño del arreglo al añadir o remover los elementos:
ar3= ar2 << “otro” # => [1, 2, 3, "otro"]
El operador << modifica el operando izquierdo, por lo que la modificación de un

arreglo puede hacerse directamente como:
ar3<<"otro mas" # => [1, 2, 3, "otro", "otro mas"]
De hecho en la penúltima expresión ar3 en realidad está recibiendo la referencia

de ar2 al cual se le añadió la cadena “otro”.
Como en C++ y Java, en Ruby el índice de un arreglo comienza con cero.
a = [1, 2, 3, [4, 5, 6]] # => [1, 2, 3, [4, 5, 6]]

a[0] # => 1
El método size puede ser utilizado para conocer el número de elementos del
arreglo:
a.size # => 4
a[3] # => [4, 5, 6]
a[3].size # => 3
a[3][0] # => 4
El tamaño del arreglo es validado:

a[5] # => nil

- 107 -
Es posible hacer uso de valores negativos como índices, y estos se tomaran de la

última posición (-1) hasta la posición negativa del tamaño del arreglo (también
posición 0:
a[-1] # => [4, 5, 6]

a[a.size*-1] # => 1

- 108 -
Probando Ruby
¿Porque no empezar a probar ruby siguiendo el tutorial el línea? Éste se encuentra

disponible en : http://tryruby.hobix.com/

- 109 -
Estructuras de control
Condicional if. Se ejecuta si la condición es verdadera.
Sintaxis:
if condicional [then]
instrucciones
[elsif condicional [then]
instrucciones]...
[else
instrucciones]
end
El if puede ser usado como un modificador de una declaración:

code if condicional
Ejemplos:
if x < 5 then
declaracion1
end
if x < 5 then
declaracion1
else
declaracion2
end
declaracion1 if y == 3
x = if a>0 then b else c end

- 110 -
Condicional unless. Ejecuta código si la condición es falsa, en caso contrario

ejecuta otro bloque de instrucciones.
Sintaxis:
unless condicional [then]

instrucciones
[else
instrucciones]
end
El unless puede ser usado como un modificador de una declaración:

instrucciones if condicional
Ejemplos:
unless x >= 5 then

declaracion1
end
unless x < 5 then

declaracion1
else
declaracion2
end
declaracion1 unless y != 3
x = unless a<=0 then c else b end
Case. Compara la expresión especificada en case con la expresión especificada en

when y ejecuta el código correspondiente. La clausula else se ejecuta en el caso
de que ningún segmento when sea ejecutado.

- 111 -
Sintaxis:
case expresión
[when expresión[, expresión...] [then]
instrucciones]...
[else
instrucciones]
end
Ejemplo:
case "Una cadena."

when "algun valor"
puts "opcion 1"
when "otro valor"
puts "opcion 2"
when /char/
puts "opcion 3"
else
puts "opcion 4"
end
Ciclo while. Se ejecuta el conjunto de instrucciones mientras la condición es

verdadera. La condición puede ser separada del conjunto de instrucciones
mediante la palabra reservada do, una línea nueva, el símbolo ‘\’, o un ‘;’.
Sintaxis:
while condicional [do]

instrucciones
end
El while puede ser usado como un modificador de una declaración:

instrucciones while condicional
ó:

- 112 -
begin
instrucciones
end while condicional
Ejecuta instrucciones mientras la condición es verdadera. En el caso del entre las

clausulas begin y end, este se ejecuta una vez antes de evaluar la condición.
Ciclo until. El ciclo until se ejecuta el conjunto de instrucciones mientras la

condición es falsa (hasta que la condición se cumpla). Puede ser separada del
código por la palabra reservada do, un salto de línea o un ‘;’. De igual forma que
el while, until puede ser usado como modificador de una declaración.
Sintaxis:
until condicional [do]

instrucciones
end
ó:
instrucciones until condicional
ó:
begin
instrucciones
end until condicional
Ciclo for. Ejecuta el conjunto de instrucciones por cada elemento en la

expresión. La expresión en el for puede ir separada por la palabra reservada do,
un salto de línea, o un ‘;’.
Sintaxis:

- 113 -
for variable[, variable...] in expresion [do]

instrucciones
end
Instrucciones break, next, redo.
break. Termina un ciclo while o until. También finaliza un método con un bloque
asociado si es usado dentro del bloque, con el método regresando el valor de nulo.
next. Salta al punto en que se evalúa la condición de un ciclo. También termina la

ejecución de un bloque si es llamado dentro de éste.
redo. Salta al punto inmediatamente posterior a la evaluación del ciclo.
Instrucciones BEGIN y END.
BEGIN. Permite declarar un conjunto de instrucciones a ejecutarse antes de que el

programa se ejecute.
BEGIN {
instrucciones
}
END. Permite declarar un conjunto de instrucciones a ejecutarse antes de finalizar

la ejecución del interprete.
END {
instrucciones
}
Algunos ejemplos:
# Ciclo 1 (while)
i=0

- 114 -
while i < list.size do

print "#{list[i]} "
i += 1
end
# Ciclo 2 (until)
i=0
until i == list.size do
print "#{list[i]} "
i += 1
end
# Ciclo 3 (for)
for x in list do
print "#{x} "
end
# Ciclo 4 (loop)
i=0
n=list.size-1
loop do
print "#{list[i]} "
i += 1
break if i > n
end
# Ciclo 6 (loop)
i=0
n=list.size-1
loop do
print "#{list[i]} "
i += 1
break unless i <= n
end
# Ciclo 7 (for)
n=list.size-1

- 115 -
for
i in 0..n do
print "#{list[i]} "
end
---
car = "Patriot"
manufacturer = case car

when "Focus": "Ford"
when "Navigator": "Lincoln"
when "Camry": "Toyota"
when "Civic": "Honda"
when "Patriot": "Jeep"
when "Jetta": "VW"
when "Ceyene": "Porsche"
when "Outback": "Subaru"
when "520i": "BMW"
when "Tundra": "Nissan"
else "Desconocido"
end
puts "El " + car + " es fabricado por " + manufacturer
--
calif = 70
result = case score

when 0..59: "Reprobado"
when 61..70: "Aprobado… apenas"
when 71..80: "Aprobado"
when 81..100: "Excelente"
else "Resultado inválido"
end
puts result
--

- 116 -
for j in 1..5 do
for i in 1..5 do
print i, " "
end
puts
end
--
for i in 1..8 do
puts i
end
--

- 117 -
Entrada y Salida básica en Ruby
Ruby proporciona instrucciones básicas de entrada y salida. Para Desplegar en la

consola, las instrucciones básicas son puts, print y printf:
puts. Despliega en la consola y añade un enter al final.

print. Despliega en la consola pero no añade el enter o salto de línea al final.
printf. Permite formatear la salida de variables de forma similas a C y Java 5.
Ejemplo:
puts "puts funciona"

puts " con saltos de linea."
print "print funciona"

print " sin saltos de linea."
printf("\n\nprintf formatea numeros como %7.2f, y cadenas como

%s.",3.14156,"esta")
La manera más simple de leer una cadena en Ruby es ocupando la función gets:
print “Introduce tu nombre: “

nom= gets

- 118 -
Abstracción de datos: Clases y objetos
Clases
Se mencionaba anteriormente que la base de la programación orientada a

objetos es la abstracción de los datos o los TDAs. La abstracción de los datos se
da realmente a través de las clases y objetos.
Def. Clase. Se puede decir que una clase es la implementación real de un

TDA, proporcionando entonces la estructura de datos necesaria y sus operaciones.
Los datos son llamados atributos y las operaciones se conocen como métodos.
[3]
La unión de los atributos y los métodos dan forma al comportamiento

(comportamiento común) de un grupo de objetos. La clase es entonces como la
definición de un esquema dentro del cual encajan un conjunto de objetos.
El comportamiento debe ser descrito en términos de responsabilidades [7].

Resolviendo el problema bajo esos términos permite una mayor independencia
entre los objetos, al elevar el nivel de abstracción.
En Programación Estructurada el programa opera sobre estructuras de datos.

En contraste en Programación Orientada a Objetos, el programa solicita a las
estructuras de datos que ejecuten un servicio.
Ejemplos de clases:
• automóvil,
• persona,
• libro,
• revista,
• reloj,
• silla,
• ...

- 119 -
Objetos e instancias
Una de las características más importantes de los lenguajes orientados a

objetos es la instanciación. Esta es la capacidad que tienen los nuevos tipos de
datos, para nuestro caso en particular las clases de ser "instanciadas" en cualquier
momento.
El instanciar una clase produce un objeto o instancia de la clase requerida.

Todos los objetos son instancia de una clase [7].
Def. Objeto. Un objeto es una instancia de una clase. Puede ser identificado
en forma única por su nombre y define un estado, el cuál es representado por los
valores de sus atributos en un momento en particular [3].
El estado de un objeto cambia de acuerdo a los métodos que le son

aplicados. Nos referimos a esta posible secuencia de cambios de estado como el
comportamiento del objeto:
Def. Comportamiento. El comportamiento de un objeto es definido por un

conjunto de métodos que le pueden ser aplicados [3].
Instanciación
Los objetos pueden ser creados de la misma forma que una estructura de
datos:
1. Estáticamente. En tiempo de compilación se le asigna un área de memoria.
2. Dinámicamente. Se le asigna un área de memoria en tiempo de ejecución y su

existencia es temporal. Es necesario liberar espacio cuando el objeto ya no es
útil; para esto puede ser que el lenguaje proporcione mecanismos de
recolección de basura.

- 120 -
En Java, los objetos sólo existen de manera dinámica, además de que

incluye un recolector de basura para no dejar como responsabilidad del usuario la
eliminación de los objetos de la memoria.
Clases en C++
Una clase entonces, permite encapsular la información a través de atributos

y métodos que utilizan la información, ocultando la información y la
implementación del comportamiento de las clases.
La definición de una clase define nuevos TDAs y la definición en C++

consiste de la palabra reservada class, seguida del nombre de la clase y
finalmente el cuerpo de la clase encerrado entre llaves y finalizando con “;”.
El cuerpo de la clase contiene la declaración de los atributos de la clase

(variables) y la declaración de los métodos (funciones). Tanto los atributos como
los métodos pertenecen exclusivamente a la clase y sólo pueden ser usados a
través de un objeto de esa clase.
Sintaxis:
class <nombre_clase> {
<cuerpo de la clase>
};
Ejemplo:
class cEjemplo1 {
int x;
float y;
void fun(int a, float b) {
x=a;
y=b;
}
};

- 121 -
Miembros de una clase en C++
Una clase está formada por un conjunto de miembros que pueden ser datos,
funciones, clases anidadas, enumeraciones, tipos de dato, etc. Por el momento nos
vamos a centrar en los datos y las funciones (atributos y métodos).
Es importante señalar que un miembro no puede ser declarado más de una

vez.16 Tampoco es posible añadir miembros después de la declaración de la clase.
Ejemplo:
class cEjemplo2{
int i;
int i; //error
int j;
int func(int, int);
};
Atributos miembro
Todos los atributos que forman parte de una clase deben ser declarados
dentro de la misma.
Métodos miembro
Los métodos al igual que los atributos, deber ser definidos en la clase, pero
el cuerpo de la función puede ir dentro o fuera de la clase. Si un método se
declara completo dentro de la clase, se considera como inline.
La declaración dentro de la clase no cambia con respecto a la declaración de

una función, salvo que se hace dentro de la clase. Veamos un ejemplo parecido al
16
Aunque existe el concepto de sobrecarga que se verá más adelante
- 122 -
inicial de esta sección, pero ahora con el cuerpo de un método fuera del cuerpo de
la clase.
Ejemplo:
//código en ejemplo3.h
class cEjemplo3 {
public:
int x;
float y;
int funX(int a) {
x=a;
return x;
}
float funY(float);
};
Podemos ver que en la definición de la clase se incluye un método en línea y

un prototipo de otro método.
Para definir un método miembro de una clase fuera de la misma, se debe

escribir antes del nombre del método, el nombre de la clase con la que el método
esta asociado. Para esto se ocupa el operador de resolución de alcance “::”.
Continuación del ejemplo:

float cEjemplo3::funY(float b){
y=b;
return y;
}
Reiteramos que al declarar los métodos fuera de la clase no puede

mencionarse la declaración de un método que no esté contemplado dentro de la
clase. Si esto fuera válido, cualquier método podría ganar acceso a la clase con
sólo declarar una función adicional.

- 123 -
Ejemplo:
//error en declaración de un método
class x{
public:
int a;
f();
};
int x::g() { //error, el metodo debe ser f()

return a*=3.1234;
}
La declaración de una función miembro es considerada dentro del ámbito de

su clase. Lo cual significa que puede usar nombres de miembros de la clase
directamente sin usar el operador de acceso de miembro de la clase.
Recordar que por convención en la programación orientada a objetos las

funciones son llamadas métodos y la invocación o llamada se conoce como
mensaje.
Un vistazo al acceso a miembros
Otra de las ventajas de la POO es la posibilidad de encapsular datos,

ocultándolos de otros objetos si es necesario. Para esto existen principalmente dos
calificadores que definen a los datos como públicos o privados.
Miembros públicos. Se utiliza cuando queremos dar a usuarios de una clase ) el

acceso a miembros de esa clase, los miembros deben ser declarados públicos.
Sintaxis:
public:
<definición de miembros>

- 124 -
Miembros privados. Si queremos ocultar ciertos miembros de una clase de los

usuarios de la misma, debemos declarar a los miembros como privados. De esta
forma nadie más que los miembros de la clase pueden usar a los miembros
privados. Por omisión los miembros se consideran privados. En una estructura se
consideran públicos por omisión.
Sintaxis:
private:
<definición de miembros>
Normalmente, los atributos de la clase deben ser privados; así como los
métodos que no sean necesarios externamente o que puedan conducir a un estado
inconsistente del objeto.17
En el caso de los atributos, estos al ser privados deberían de contar con

métodos de modificación y de consulta pudiendo incluir alguna validación.
Es una buena costumbre de programación accesar a los atributos solamente

a través de las funciones de modificación, sobre todo si es necesario algún tipo de
verificación sobre el valor del atributo.
Ejemplo:
//código en ejemplo3.h
class cFecha {
private:
int dia;
int mes;
int an;
public:
char setDia(int); //poner día
int getDia(); //devuelve día
char setMes(int);
17
Un estado inconsistente sería ocasionado por una modificación indebida de los datos, por ejemplo una modificación sin
validación.
- 125 -
int getMes();
char setAn(int);
int getAn();
};
Objetos de clase en C++
Ya se ha visto como definir una clase, declarando sus atributos y sus

operaciones, mismas que pueden ir dentro de la definición de la clase (inline) o
fuera. Ahora vamos a ver como es posible crear objetos o instancias de esa clase.
Hay que recordar que una de las características de los objetos es que cada
uno guarda un estado particular de acuerdo al valor de sus atributos18.
Lo más importante de los lenguajes orientados a objetos es precisamente el

objeto, el cual es una identidad lógica que contiene datos y código que manipula
esos datos.
En C++, un objeto es una variable de un tipo definido por el usuario [8].
Un ejemplo completo:
#include <iostream>
class cEjemplo3 {
public:
int i;
int j;
};
int main() {
cEjemplo3 e1;
cEjemplo3 e2;
18
A diferencia de la programación modular, donde cada módulo tiene un solo estado.
- 126 -
e1.i=10;
e1.j=20;
e2.i=100;
e2.j=20;
cout<<e1.i<<endl;
cout<<e2.i<<endl;
return 0;
}
Otro ejemplo, una cola:
class cCola{
private:
int q[10];
int sloc, rloc;
public:
void ini() { //funci¢n en l¡nea
sloc=rloc=-1;
}
char set(int);
int get();
};
#include <iostream>
#include "cCola.h"
char cCola::set(int val){

if(sloc>=10){
cout<<"la cola esta llena";
return 0;
}
sloc++;
q[sloc]=val;

- 127 -
return 1;
}
int cCola::get(){
if(rloc==sloc)
cout<<"la cola esta vacia";
else {
rloc++;
return q[rloc];
}
}
//cola definida en un arreglo

#include <iostream>
#include "cCola.h"
int main(){
cCola a,b, *pCola= new cCola; //¢ *pCola=NULL y despu‚s
asignarle
a.ini();
b.ini();
pCola->ini();
a.set(1);
b.set(2);
pCola->set(3);
a.set(11);
b.set(22);
pCola->set(33);
cout<<a.get()<<endl;
cout<<b.get()<<endl;
cout<<pCola->get()<<endl;
delete pCola;
return 0;
}

- 128 -
Nota: tomar en cuenta las instrucciones siguientes para el precompilador en

el manejo de múltiples archivos.
#ifndef CCOLA_H
#define CCOLA_H
<definición de la clase>
#endif
Clases en Java
La definición en Java, de manera similar a C++, consiste de la palabra

reservada class, seguida del nombre de la clase y finalmente el cuerpo de la clase
encerrado entre llaves.
Sintaxis:
class <nombre_clase> {
}
Ejemplo19:
public class cEjemplo1 {

int x;
float y;
void fun(int a, float b) {
x=a;
y=b;
}
}
19
Algunos ejemplos como este no son programas completos, sino simples ejemplos de clases. Podrán ser
compilados pero no ejecutados directamente. Para que un programa corra debe contener o ser una clase
derivada de applet, o tener un método main.
- 129 -
Miembros de una clase en Java
Los miembros en Java son esencialmente los atributos y los métodos de la

clase.
Ejemplo:
class cEjemplo2{
int i;
int i; //error
int j;
int func(int, int){}
}
Atributos miembro
dentro de la misma.
La sintaxis mínima es la siguiente:
tipo nombreAtributo;
Los atributos pueden ser inicializados desde su lugar de declaración:
tipo nombreAtributo = valor;
ó, en el caso de variables de objetos:
tipo nombreAtributo = new Clase();

- 130 -
Métodos miembro
Un método es una operación que pertenece a una clase. No es posible

declarar métodos fuera de la clase. Además, en Java no existe el concepto de
método prototipo como en C++.
Sin embargo, igual que en C++, la declaración de una función ó método

miembro es considerada dentro del ámbito de su clase.
La sintaxis básica para declarar a un método:
tipoRetorno nombreMétodo ( [<parámetros>] ) {

<instrucciones>
}
Un aspecto importante a considerar es que el paso de parámetros en Java es

realizado exclusivamente por valor. Datos básicos y objetos son pasados por
valor. Pero los objetos no son pasados realmente, se pasan las referencias a los
objetos (i.e., una copia de la referencia al objeto).
Un vistazo al acceso a miembros
Si bien en Java existen también los miembros públicos y privados, estos

tienen una sintaxis diferente a C++. En Java se define el acceso a cada miembro
de manera unitaria, al contrario de la definición de acceso por grupos de
miembros de C++.
Miembros públicos.
Sintaxis:
public <definición de miembro>
Miembros privados.

- 131 -
Sintaxis:
private <definición de miembros>
Recordatorio: Es una buena costumbre de programación acceder a los atributos

solamente a través de las funciones de modificación, sobre todo si es necesario
algún tipo de verificación sobre el valor del atributo. Estos métodos de acceso y
modificación comúnmente tienen el prefijo get y set, respectivamente.
Ejemplo:
class Fecha {
private int dia;
private int mes, an;
public boolean setDia(int d){} //poner día

public int getDia() {} //devuelve día
public boolean setMes(int m){}
public int getMes(){}
public boolean setAn(int a) {}
public int getAn() {}
}
Objetos de clase en Java
En Java todos los objetos son creados dinámicamente, por lo que se necesita
reservar la memoria de estos en el momento en que se van a ocupar. El operador
de Java está basado también en el de C++ y es new.20
Asignación de memoria al objeto
20
La instrucción new, ya había sido usada para reservar memoria a un arreglo, ya que estos son considerados
objetos.
- 132 -
El operador new crea automáticamente un área de memoria del tamaño

adecuado, y regresa la referencia del área de memoria. Esta referencia debe de
recibirla un identificador de la misma clase de la que se haya reservado la
memoria.
Sintaxis:
identificador = new Clase();
ó en el momento de declarar a la variable de objeto:
Clase identificador = new Clase();
El concepto de new va asociado de la noción de constructor, pero esta se

verá más adelante, por el momento basta con adoptar esta sintaxis para poder
completar ejemplos de instanciación.
public class Ejemplo3 {
public int i, j;
public static void main(String argv[]) {

Ejemplo3 e3= new Ejemplo3();
Ejemplo3 e1= new Ejemplo3();
e1.i=10;
e1.j=20;
e3.i=100;
e3.j=20;
System.out.println(e1.i);
System.out.println(e3.i);
}
}
Otro ejemplo, una estructura de cola:
class Cola{
- 133 -
private int q[];

private int sloc, rloc;
public void ini() {

sloc=rloc=-1;
q=new int[10];
}
public boolean set(int val){

if(sloc>=10){
System.out.println("la cola esta llena");
return false;
}
sloc++;
q[sloc]=val;
return true;
}
public int get(){

if(rloc==sloc) {
System.out.println("la cola esta vacia");
return -1;
}
else {
rloc++;
return q[rloc];
}
}
}
public class PruebaCola {

public static void main(String argv[]){
Cola a= new Cola(); // new crea realmente el objeto

Cola b= new Cola(); // reservando la memoria
Cola pCola= new Cola();
//Inicializacion de los objetos

a.ini();

- 134 -
b.ini();
pCola.ini();
a.set(1);
b.set(2);
pCola.set(3);
a.set(11);
b.set(22);
pCola.set(33);
System.out.println(a.get());
System.out.println(a.get());
System.out.println(b.get());
System.out.println(b.get());
System.out.println(pCola.get());
System.out.println(pCola.get());
}
}

- 135 -
Clases en Ruby
La definición en Ruby, de manera similar a Java y C++, consiste de la

palabra reservada class, seguida del nombre de la clase y finalmente el cuerpo de
la clase [9].
Sintaxis:
class <nombre_clase>
end
Si la clase es contenida en un archivo la convención es que el nombre del archivo

coincida con el nombre de la clase pero iniciando en minúsculas. Una clase
Prueba estará idealmente en un archivo prueba.rb (en Windows se usa .rbw)
Ejemplo21:
class Ejemplo01
def fun a,b
x=a
y=b
end
end
Miembros de una clase en Ruby
Los miembros en Ruby son esencialmente los atributos y los métodos de la

clase.
21
Algunos ejemplos como este no son programas completos, sino simples ejemplos de clases. Ruby es un
lenguaje interpretado. No existe un método principal que inicie la ejecución. El interprete recibe una lista de
instrucciones y éste comienza ejecutando de la línea inicial hasta la última línea.
- 136 -
Métodos miembro
Un método es una operación que pertenece a una clase. Los métodos son
muy importantes en Ruby. En Ruby no existen funciones, pues todo el código es
representad en métodos (asociados a objetos). Aunque Ruby permite definir
código como funciones en otros lenguajes, en realidad ese código es un método
asociado (por omisión) a un objeto.
La sintaxis básica para declarar a un método:
def nombreMétodo [( <parámetros> ) ]

<instrucciones>
end
Un aspecto importante a considerar es que la lista de parámetros, al igual que el

uso de variables, no requiere definir el tipo de dato, pues este se determina en el
momento de la llamada al método.
Es posible añadir los símbolos ! o ? al final del nombre de un método. ! indica

que el método requiere más atención que la variante con el mismo nombre sin el
!. El símbolo ? indicaría que el método retorna un resultado boleano.
En Ruby es posible que un método definido para una clase quede indefinido:
undef nombreMétodo [( <parámetros> ) ]
Por ejemplo:
class Foo
def foo
end
end
...
undef foo

- 137 -
Un vistazo al acceso a métodos
Si bien en Ruby existen también los miembros públicos y privados, estos

son usados para proveer acceso a los métodos, puesto que los atributos son
privados.
Métodos públicos. Accesibles donde la clase es visible.
Sintaxis:
public <lista de métodos>
Métodos privados. Accesibles solo por instancias de la clase.
Sintaxis:
private <lista de métodos>
La lista de métodos públicos o privados debe hacer referencia a métodos

previamente definidos. Esto puede ser la lista de métodos después de ser
definidos, o definirse el método en ese momento. En Ruby, los métodos son
públicos por omisión [10].
Ejemplo:
class A
private
def metodo_privado
# codigo
end
end

- 138 -
Atributos miembro
dentro de la misma. En Ruby los atributos son llamasoa variables de instancia, y
no requieren ser declarados fuera de los métodos. Podemos usar variables de
instancia conforme se necesiten. Una variable de instancia debe llevar como
prefijo el símbolo @, por ejemplo:
@variableInstancia
Ejemplo:
class InstTest
def set_foo(n)
@foo = n
end
def set_bar(n)
@bar = n
end
end
El detalle es que en Ruby las variables de instancia no son accesibles

externamente. Para poder accederlas debemos crear métodos de acceso como en
el ejemplo pasado, o definir explícitamente el acceso a los atributos, lo que genera
métodos con el nombre del atributo ( pero sin el @ ). Existen 3 tipos de acceso a
los atributos:
attr_accesor. Genera acceso de lectura y escritura a la variable de instancia.

attr_reader. Genera acceso de lectura sobre la variable de instancia.
attr_writer. Proporciona acceso de escritura sobre la variable de instancia.
Ejemplo:
class Usuario
attr_accessor :nombre
attr_accessor :apellidos

- 139 -
attr_reader :login
attr_writer :password
...
def muestra
@nombre+” “+@apellidos
end
end
Objetos de clase en Ruby
En Ruby todos los números, arreglos, cadenas y demás entidades son

objetos, lo que permite aplicar métodos definidos para esos objetos directamente
a las literales:
10.succ # 11
"hola".upcase # "HOLA"
[2,1,5,3,4].sort # [1,2,3,4,5]
objeto.metodo
Esto implicaría que cada objeto en Ruby es un objeto de alguna clase. De

hecho es posible preguntarle a un objeto a que clase pertenece:
"hola".class
Asignación de memoria al objeto
En Ruby, un objeto es instanciado mediante la ejecución del método new, el

crea automáticamente un área de memoria del tamaño adecuado, y regresa la
referencia del área de memoria. El objeto instanciado típicamente es asignado a
una variable.
Sintaxis:
identificador = Clase.new

- 140 -
class Ejemplo3
@i # no es necesario
@j # especificar los atributos
def unMetodo x,y
@i=x
@j=y
puts "El valor de i es " + @i.to_s
puts "El valor de j es " + @j.to_s
end
end
require "Ejemplo3"
# ó load "Ejemplo3.rb"
obj1 = Ejemplo3.new
obj2 = Ejemplo3.new
obj1.unMetodo 10,20
obj2.unMetodo 100, 20
Otro ejemplo, una estructura de cola:
class Cola
@q=[]
@sloc= @rloc=-1
def ini
@sloc= @rloc=-1
@q=[]
end
def set val

if @sloc>1000
puts "La cola esta llena"
return false
end
@sloc+=1
@q[@sloc]=val
- 141 -
return true
end
def get
if @rloc == @sloc then
puts "La cola esta vacia"
return false
else
@rloc+=1
return @q[@rloc]
end
end
end
require "Cola"
a = Cola.new
b = Cola.new
a.ini
b.ini
a.set 1
b.set 2
a.set 11
b.set(22)
puts a.get
puts a.get
puts b.get
puts b.get()
a.get

- 142 -

- 143 -
Alcance de Clase en C++
El nombre de un miembro de una clase es local a la clase. Las funciones no

miembros se definen en un alcance de archivo.
Dentro de la clase los miembros pueden ser accesados directamente por

todos los métodos miembros. Fuera del alcance la clase, los miembros de la clase
se pueden utilizar seguidos del operador de selección de miembro de punto . ó
del operador de selección de miembro de flecha , posteriormente al nombre
de un objeto de clase.
Ejemplo:
class cMiClase{
public:
int otraFuncion();
};
int main () {
cMiClase cM;
cM.otraFuncion();
return 0;
}
Alcance de Clase en Java
El nombre de un miembro de una clase es local a la clase.
Dentro de la clase, los miembros pueden ser accesados directamente por

todos los métodos miembros. Fuera del alcance la clase, los miembros de la clase
se pueden utilizar seguidos del operador de selección de miembro de punto ‘.’ ,
posteriormente al nombre de un objeto de clase.

- 144 -
Ejemplo:
class MiClase{
public void otraFuncion(){
System.out.println("Metodo de la clase MiClase");
}
}
public class Alcance {

public static void main (String argv[]) {
MiClase cM= new MiClase();
cM.otraFuncion();
}
}
Alcance de Clase en Ruby
Los atributos son privados y accesibles únicamente mediante métodos

definidos por el programador o mediante los modificadores de accesoa los
atributos. El nombre del método de una clase es local a la clase.
Dentro de la clase, los miembros pueden ser accesados directamente por

todos los métodos miembros. Fuera del alcance la clase, únicamente los métodos
de la clase se pueden utilizar, seguidos del operador de selección de miembro de
punto ‘.’ , posteriormente al nombre de un objeto de clase.
Ejemplo:
class MiClase
public
def otraFuncion
puts "Metodo de la clase MiClase"
end
end
def miMain

- 145 -
cM= MiClase.new
cM.otraFuncion
end
miMain
Usando la palabra reservada this en C++ y Java
Cuando en algun punto dentro del código de algunos de los métodos se

quiere hacer referencia al objeto ligado en ese momento con la ejecución del
método, podemos hacerlo usando la palabra reservada this.
Una razón para usarlo es querer tener acceso a algún atributo posiblemente
oculto por un parámetro del mismo nombre.
También puede ser usado para regresar el objeto a través del método, sin
necesidad de realizar una copia en un objeto temporal.
La sintaxis es la misma en C++ y en Java, con la única diferencia del

manejo del operador de indirección “*” si, por ejemplo, se quiere regresar una
copia y no la referencia del objeto.
Ejemplo en C++:
Fecha Fecha::getFecha(){
return *this;
}
Ejemplo en Java:
class Fecha {
private int dia;
private int mes, an;
…
public Fecha getFecha(){
return this;
- 146 -
}
…
}
Usando la palabra reservada self en Ruby
En Ruby, para hacer referencia en un método al objeto donde es ejecutado el

método (el mismo que recibe el mensaje) se usa la palabra reservada self, en lugar
de this.
Ejemplo:
class SelfEjemplo
@x=0
@y=0
def getSelfEjemplo
return self
end
attr_accessor :x, :y
end
#código de prueba
obj1= SelfEjemplo.new
obj1.x=10
puts obj1.x
obj1.y="YY"
puts obj1.y
obj2=obj1.getSelfEjemplo
puts obj2.x
obj1.y=123
puts obj1.y # despliega 123
puts obj2.y # despliega 123

- 147 -
Sobrecarga de operaciones
Es posible tener el mismo nombre para una operación con la condición de

que tenga parámetros diferentes. La diferencia debe de ser al menos en el tipo de
datos.
Si se tienen dos o más operaciones con el mismo nombre y diferentes

parámetros se dice que dichas operaciones están sobrecargadas.
El compilador sabe que operación ejecutar a través de la firma de la

operación, que es una combinación del nombre de la operación y el número y tipo
de los parámetros.
El tipo de regreso de la operación puede ser igual o diferente.
La sobrecarga22 de operaciones sirve para hacer un código más legible y

modular. La idea es utilizar el mismo nombre para operaciones relacionadas. Si
no tienen nada que ver entonces es mejor utilizar un nombre distinto. A
contianuación ejemplos de sobrecarga en C++ y Java.
Ejemplo en C++:
class MiClase{
int x;
public:
void modifica() {
x++;
}
void modifica(int y){
x=y*y;
}
}
22
También conocida como homonimia.
- 148 -
Ejemplo 2 en C++:
//fuera de POO
#include <iostream>
int cuadrado(int i){

return i*i;
}
double cuadrado(double d){
return d*d;
}
int main() {
cout<<"10 elevado al cuadrado: "<<cuadrado(10)<<endl;
cout<<"10.5 elevado al cuadrado: "<<cuadrado(10.5)<<endl;
return 0;
}
Ejemplo en Java:
class MiClase{
int x;
public void modifica() {
x++;
}
public void modifica(int y){
x=y*y;
}
}
Ruby no soporta sobrecarga de operaciones. En Ruby la firma de un método

es su nombre. Si dos métodos son definidos con el mismo nombre, la última
implementación definida es la que es esperada.
Ejemplo en Ruby:
class MiClase
attr_reader :x

- 149 -
def modifica
@x+=1
end
def modifica y
@x=y*y
end
end
#prueba
mc=MiClase.new
puts mc.x
# mc.modifica -- Error pues se ha redefinido el método
mc.modifica 10
puts mc.x
Constructores y destructores en C++
Con el manejo de los tipos de datos primitivos, el compilador se encarga de

reservar la memoria y de liberarla cuando estos datos salen de su ámbito.
En la programación orientada a objetos, se trata de proporcionar

mecanismos similares, aunque con mayor funcionalidad. Cuando un objeto es
creado es llamado un método conocido como constructor, y al salir se llama a otro
conocido como destructor. Si no se proporcionan estos métodos se asume la
acción más simple.
Constructor
Un constructor es un método con el mismo nombre de la clase. Este método

no puede tener un tipo de dato y si puede permitir la homonimia o sobrecarga.

- 150 -
Ejemplo:
class Cola{
private:
int q[100];
int sloc, rloc;
public:
Cola( ); //constructor
void put(int);
int get( );
};
//implementación del constructor

Cola::Cola ( ) {
sloc=rloc=0;
cout<<"Cola inicializada \n";
}
Un constructor si puede ser llamado desde un método de la clase.
Constructor de Copia
Es útil agregar a todas las clases un constructor de copia que reciba como
parámetro un objeto de la clase y copie sus datos al nuevo objeto.
C++ proporciona un constructor de copia por omisión, sin embargo es una

copia a nivel de miembro y puede no realizar una copia exacta de lo que
queremos. Por ejemplo en casos de apuntadores a memoria dinámica, se tendría
una copia de la dirección y no de la información referenciada.
Sintaxis:
<nombre clase>(const <nombre clase> &<objeto>);
Ejemplo:

- 151 -
//ejemplo de constructor de copia

#include <iostream>
#include <time.h>
#include <stdlib.h>
class Arr{
private:
int a[10];
public:
Arr(int x=0) {
for( int i=0; i<10; i++){
if (x==0)
x=rand();
a[i]=x;
}
}
Arr(const Arr &copia){ //constructor de copia

for( int i=0; i<10; i++)
a[i]=copia.a[i];
}
char set(int, int);

int get(int) const ;
int get(int);
};
char Arr::set(int pos, int val ){

if(pos>=0 && pos<10){
a[pos]=val;
return 1;
}
return 0;
}
int Arr::get(int pos) const {
if(pos>=0 && pos<10)
return a[pos];

- 152 -
// a[9]=0; error en un metodo constante

return 0;
}
int Arr::get(int pos) { //no es necesario sobrecargar

if(pos>=0 && pos<10) // si el metodo no modifica
return a[pos];
return 0;
}
int main(){
Arr a(5), b;
srand( time(NULL) );
a.set(0,1);
a.set(1,11);
cout<<a.get(0)<<endl;
b.set(0,2);
b.set(1,22);
cout<<b.get(0)<<endl;
Arr d(a);
cout<<d.get(0)<<endl;
cout<<d.get(1)<<endl;
return 0;
}
Destructor
La contraparte del constructor es el destructor. Este se ejecuta momentos

antes de que el objeto sea destruido, ya sea porque salen de su ámbito o por medio
de una instrucción delete. El uso más común para un destructor es liberar la
memoria asignada dinámicamente, aunque puede ser utilizado para otras
operaciones de finalización, como cerrar archivos, una conexión a red, etc.

- 153 -
El destructor tiene al igual que el constructor el nombre de la clase pero con

una tilde como prefijo (~).
El destructor tampoco regresa valores ni tiene parámetros.
Ejemplo:
class Cola{
private:
int q[100];
int sloc, rloc;
public:
Cola( ); //constructor
~Cola(); //destructor
void put(int);
int get( );
};
Cola::~Cola( ){
cout<<"cola destruida\n";
}
Ejemplo completo de Cola con constructor y destructor:

//cola definida en un arreglo
//incluye constructores y destructores de ejemplo
#include <iostream>
#include <string.h>
#include <stdio.h>
class Cola{
private:
int q[10], sloc, rloc;
char *nom;

- 154 -
public:
Cola(char *cad=NULL) { //funcion en linea
if(cad){ //cadena!=NULL
nom=new char[strlen(cad)+1];
strcpy(nom, cad);
}else
nom=NULL;
sloc=rloc=-1;
}
~Cola( ) {
if(nom){ //nom!=NULL
cout<<"Cola : "<<nom<<" destruida\n";
delete [] nom;
}
}
char set(int);
int get();
};
char Cola::set(int val){

if(sloc>=10){
cout<<"la cola esta llena";
return 0;
}
sloc++;
q[sloc]=val;
return 1;
}
int Cola::get(){
if(rloc==sloc)
cout<<"la cola esta vacia";
else {
rloc++;
return q[rloc];
}
return 0;
}
int main(){

- 155 -
Cola a("Cola a"),b("Cola b"),

*pCola= new Cola("Cola dinamica pCola");
a.set(1);
b.set(2);
pCola->set(3);
a.set(11);
b.set(22);
pCola->set(33);
delete pCola;
}
Constructores y finalizadores en Java
En Java, cuando un objeto es creado es llamada un método conocido como

constructor, y al salir se llama a otro conocido como finalizador23. Si no se
proporcionan estos métodos se asume la acción más simple.
Constructor
Un constructor es un método con el mismo nombre de la clase. Este método

no puede tener un tipo de dato de retorno y si puede permitir la homonimia o
sobrecarga, y la modificación de acceso al mismo.
Ejemplo:
public class Cola{
private int q[];
23
En C++ no existe el concepto de finalizador, sino el de destructor, porque su tarea primordial es liberar la
memoria ocupada por el objeto, cosa que no es necesario realizar en Java.
- 156 -
private int sloc, rloc;

public void put(int){ ... }
public int get( ){ ... }
// implementación del constructor
public Cola ( ) {
sloc=rloc=0;
q= new int[100];
System.out.println("Cola inicializada ");
}
}
El constructor se ejecuta en el momento de asignarle la memoria a un

objeto, y es la razón de usar los paréntesis junto al nombre de la clase al usar la
instrucción new:
Fecha f = new Fecha(10,4,2007);
Si no se especifica un constructor, Java incluye uno predeterminado, que

asigna memoria para el objeto e inicializa las variables de instancia a valores
predeterminados. Este constructor se omite si el usuario especifica uno o más por
parte del programador.
Finalizador
La contraparte del constructor en Java es el método finalize o finalizador.

Este se ejecuta momentos antes de que el objeto sea destruido por el recolector de
basura. El uso más común para un finalizador es liberar los recursos utilizados
por el objeto, como una conexión de red o cerrar algún archivo abierto.
No es muy común utilizar un método finalizador, más que para asegurar

situaciones como las mencionadas antes. El método iría en términos generales
como se muestra a continuación24:
24
No se ha mencionado el modificador protected. Este concepto se explicará una vez que se haya visto el
manejo de herencia.
- 157 -
protected void finalize() {

<instrucciones>
}
El finalizador puede ser llamado como un método normal, inclusive puede ser
sobrecargado, pero un finalizador con parámetros no puede ser ejecutado
automáticamente por la máquina virtual de Java. Se recomiendo evitar el definir
un finalizador con parámetros.
Inicializadores en Ruby
En Ruby, el método que podemos usar para inicializar un objeto es llamado

initialize. No es llamado consturctor porque, en Ruby, son internamente dos
procesos separados. El método initialize no es un constructor y es definido
automáticamente como privado.
La explicación para esto es que las clases en Ruby son instancias de la clase
Class. Por cada clase definida, un objeto de tipo Class es creado y asignado a una
constante del nombre especificado en la declaración de la clase. Cuando el
método new es llamado (NombreClase.new) para crear un objeto, se ejecuta por
default el método new de Class, el cual ejecuta al método allocate para asignar la
memoria del objeto, y por último, el método initialize del nuevo objeto es
ejecutado.
Sintaxis
class NombreClase
def initialize [(lista de parámetros)]
<código>
end
...
end

- 158 -
…
obj = NombreClase.new [(parámetros)]
Ejemplo:
class Cola
def initialize
@sloc= @rloc=-1
@q=[]
end
...
end

- 159 -
Miembros estáticos en C++
Cada objeto tiene su propio estado, pero a veces es necesario tener valores
por clase y no por objeto. En esos casos se requiere tener atributos estáticos que
sean compartidos por todos los objetos de la clase.
Existe solo una copia de un miembro estático y no forma parte de los

objetos de la clase. Este tipo de miembro son también conocidos como miembros
de clase.
Clase
(Estado de laclase)
Objeto 1
(Estadodel objeto)
Objeto 2
(Estadodel objeto)
Objeto n
(Estadodel objeto)
Ejemplo:
class Objeto{
private:
char nombre[10];
static int numObjetos;
public:
Objeto(char *cadena=NULL);
~Objeto();
};
Objeto::Objeto(char *cadena){
if(cadena!=NULL)
strcpy(nombre, cadena);
else
nombre=NULL;

- 160 -
numObjetos++;
}
Objeto::~Objeto(){
numObjetos--;
}
Un miembro estático es accesible desde cualquier objeto de la clase o

mediante el operador de resolución de alcance binario (::) y el nombre de la clase,
dado que el miembro estático existe aunque no haya instancias de la clase.
Sin embargo, el acceso sigue restringido bajo las reglas de acceso a

miembros:
• Si se quiere accesar a un miembro estático que es privado deberá hacerse

mediante un método público.
• Si no existe ninguna instancia de la clase entonces deberá ser por medio
de un método público y estático.
Además, un método estático solo puede tener acceso a miembros estáticos.
Los atributos estáticos deben de ser inicializados al igual que los atributos
constantes, fuera de la declaración de la clase. Por ejemplo:
int Clase::atributo=0; int const Clase::ATRCONST=50;
Ejemplo :
//prueba de miembros estáticos

#include <iostream>
#include <stdio.h>
#include <string.h>
class Persona{
private:

- 161 -
static int nPersonas;

static const int MAX;
char *nombre;
public:
Persona(char *c=NULL){
if(c!=NULL){
nombre= new char[strlen(c)+1];
strcpy(nombre, c);
cout<<"Persona: "<<nombre<<endl;
}else{
nombre=NULL;
cout<<"Persona: "<<endl;
}
nPersonas++;
}
~Persona(){
cout<<"eliminando persona : "<<nombre<<endl;
if(nombre)
delete []nombre;
nPersonas--;
}
static int getMax(){

return MAX;
}
static int getnPersonas(){

return nPersonas;
}
};
int Persona::nPersonas=0;
const int Persona::MAX=10;
int main() {
cout<<"Máximo de personas: "<<Persona::getMax()<<endl;

- 162 -
cout<<"Número de personas:
"<<Persona::getnPersonas()<<endl;
Persona per1;
cout<<"Máximo de personas: "<<Persona::getMax()<<endl;
cout<<"Número de personas: "
<<Persona::getnPersonas()<<endl;
Persona per2("persona 2");

cout<<"Máximo de personas: "<<per2.getMax()<<endl;
cout<<"Número de personas: "<<per2.getnPersonas()<<endl;
return 0;
}
Miembros estáticos en Java
Un miembro estático en Java se maneja de la misma forma que en C++.

Cada uno de los objetos tiene su propio estado independiente del resto de los
objetos, compartiendo al mismo tiempo un estado común al tener todos los
objetos acceso al estado de la clase, el cual es único y existe de forma
independiente.
Ejemplo:
public class Objeto{
private String nombre;
private static int numObjetos;
public Objeto(String cadena){
if(cadena.length()!=0)
nombre=cadena;
else
nombre="cadena por omision";
numObjetos++;
}
public static int getNumObjetos(){

return numObjetos;
}

- 163 -

System.out.println("Objetos: " +
getNumObjetos());
Objeto.getNumObjetos());
Objeto uno,dos;
uno= new Objeto("");
dos= new Objeto("Objeto dos");
uno.getNumObjetos());
dos.getNumObjetos());
}
}
Otro ejemplo :
//prueba de miembros estáticos
public class Persona{
private static int nPersonas=0;
private static final int MAX=10;
String nombre;
public Persona(String c){

if(c.length()!=0)
nombre= new String(c);
else
nombre="";
System.out.println("Persona: "+nombre);
nPersonas++;
}
public static int getMax(){

return MAX;
}
public static int getnPersonas(){
return nPersonas;
}

- 164 -

System.out.println("Maximo de personas:
"+Persona.getMax());
System.out.println("Numero de personas:
"+Persona.getnPersonas());
Persona per1= new Persona("");

Persona per2= new Persona("persona 2");

"+per2.getMax());
"+per2.getnPersonas());
Persona per3= new Persona("persona 3");

}
}

- 165 -
Miembros de clase en Ruby
Los elementos estáticos en Ruby son conocidos como miembros de clase, el

cual es un término también usado en otros lenguajes debido a que el ámbito de los
miembros va más allá del objeto pues existen en la clase sin depender de un
objeto en particular y representan, como ya mencionamos, un estado de la clase.
Atributos de clase
Las variables de clase en Ruby son nombradas usando @@ como prefijo y

deben ser inicializadas antes de ser usadas en definiciones de métodos.
Referenciar un atributo de clase no inicializado genera un error. Las variables de
clase son compartidas entre descendientes de las clases donde estas fueron
definidas.
Métodos de clase
Los métodos de clase son definidos en Ruby usando como prefijo el nombre
de la clase o la palabra reservada self seguido de punto y el nombre del método de
clase. self se resuelve como el nombre de la clase en este caso, siendo un
comportamiento distinto a cuando es usado dentro de un método (self se resuelve
como el objeto en ejecución).
Ejemplo:
class Persona
@@nPersonas=0
@@MAX=100 # no es una constante
@nombre
def initialize nom
@nombre=nom
puts "Persona: " + @nombre if nom.size>0
@@nPersonas+=1
end

- 166 -
def self.getMax
return @@MAX
end
def Persona.getnPersonas
return @@nPersonas
end
end
#código principal
puts "Numero maximo de personas: #{Persona.getMax}"

puts "Numero de personas: #{Persona.getnPersonas}"
per1 = Persona.new "Persona 1"

puts "Numero maximo de personas: #{Persona.getMax}"
puts "Numero de personas: #{Persona.getnPersonas}"
per2 = Persona.new "Persona 2"

puts Persona.getMax
puts Persona.getnPersonas
# puts per2.getMax -- error
A diferencia de C++ y Java, en Ruby un método de clase no puede ser

accedido mediante un objeto. Un método de clase solo puede ser usado
externamente mediante el nombre de la clase.

- 167 -
Objetos constantes en C++
Es posible tener objetos de tipo constante, los cuales no podrán ser

modificados en ningún momento.25 Tratar de modificar un objeto constante se
detecta como un error en tiempo de compilación.
Sintaxis:
const <clase> <lista de objetos>; const cHora h1(9,30,20);
Para estos objetos, algunos compiladores llegan a ser tan rígidos en el

cumplimiento de la instrucción, que no permiten que se hagan llamadas a
métodos sobre esos objetos. La compilación estandar permite la ejecución de
métodos, siempre y cuando no modifiquen el estado del objeto.
Si se quiere consultar al objeto mediante llamadas a métodos get, lo

correcto es declarar métodos con la palabra reservada const, para permitirles
actuar libremente sobre los objetos sin modificarlo. La sintaxis requiere añadir
después de la lista de parámetros la palabra reservada const en la declaración y en
su definición.
Sintaxis:
Declaración.
<tipo> <nombre> (<parámetros>) const;
Definición del método fuera de la declaración de la clase.
<tipo> <clase> :: <nombre> (<parámetros>) const {

<código>
}
25
Ayuda a cumplir el principio del mínimo privilegio, donde se debe restringir al máximo el acceso a los
datos cuando este acceso estaría de sobra. [1]
- 168 -
Definición del método dentro de la declaración de la clase.
<tipo> <nombre> (<parámetros>) const {

<código>
}
Los compiladores generalmente restringen el uso de métodos constantes a

objetos constantes. Para solucionarlo es posible sobrecargar el método con la
única diferencia de la palabra const, aunque el resto de la firma del método sea la
misma.
Un método puede ser declarado dos veces tan sólo con que la firma del
método difiera por el uso de const. Objetos constantes ejecutarán al método
definido con const, y objetos variables ejecutarán al método sin esta restricción.
De hecho, un objeto variable puede ejecutar el método no definido con const por
lo que si el objetivo del método es el mismo, y este no modifica al objeto (e.g.,
métodos tipo get) bastaría con definir al método una vez.26
Los constructores no necesitan la declaración const, puesto que deben poder

modificar al objeto.
Ejemplo:
#include <iostream>
#include <time.h>
#include <stdlib.h>
class Arr{
private:
int a[10];
public:
26
Además, declarar a los métodos get y otros métodos que no modifican al objeto con el calificador const es
una buena práctica de programación.
- 169 -
Arr(int x=0) {
srand( time(NULL) );
for( int i=0; i<10; i++){
if (x==0)
x=rand()%100;
a[i]=x;
}
}
char set(int, int);
int get(int) const ;
int get(int);
};
char Arr::set(int pos, int val ){

if(pos>=0 && pos<10){
a[pos]=val;
return 1;
}
return 0;
}
int Arr::get(int pos) const {

if(pos>=0 && pos<10)
return a[pos];
// a[9]=0; error en un método constante
return 0;
}
int Arr::get(int pos) { //no es necesario sobrecargar

if(pos>=0 && pos<10) // si el método no modifica
return a[pos];
return 0;
}
int main(){
const Arr a(5),b;
Arr c;
// a.set(0,1); //error llamar a un método no const

- 170 -
// b.set(0,2); // para un objeto constante (comentar estas

lineas)
c.set(0,3);
// a.set(1,11); //error llamar a un método no const
// b.set(1,22); // para un objeto constante (comentar estas
lineas)
c.set(1,33);
cout<<a.get(0)<<endl; // ejecuta int get(int) const ;
cout<<c.get(0)<<endl; // ejecuta int get(int);
cout<<c.get(1)<<endl;
return 0;
}
Objetos finales en Java
Ya se mencionó en la sección de fundamentos de Java el uso de la palabra

reservada final, la cual permite a una variable ser inicializada sólo una vez. En el
caso de los objetos o referencias a los objetos el comportamiento es el mismo. Si
se agrega la palabra final a la declaración de una referencia a un objeto, significa
que la variable podrá ser inicializada una sola vez, en el momento que sea
necesario.
Sintaxis:
final <clase> <lista de identificadores de objetos>;
final Hora h1= new Hora(9,30,20);
Es importante remarcar que no es el mismo sentido de const en C++. Aquí

lo único que se limita es la posibilidad de una variable de referencia a ser
inicializada de nuevo, pero no inhibe la modificación de miembros.

- 171 -
Por ejemplo:
final Light aLight = new Light(); // variable local final
aLight.noOfWhatts = 100; //Ok. Cambio en el edo. del objeto
aLight = new Light(); // Inválido. No se puede modificar la

referencia
Ejemplo:
class Fecha {
private int dia;
private int mes, año;
public Fecha(){
dia=mes=1;
año=1900;
}
public boolean setDia(int d){
if (d >=1 && d<=31){
dia= d;
return true;
}
return false;
} //poner día
public int getDia() {
return dia;
} //devuelve día
public boolean setMes(int m){
if (m>=1 && m<=12){
mes=m;
return true;
}
return false;
}
public int getMes(){
return mes;
}
public boolean setAño(int a) {

- 172 -
if (a>=1900){
año=a;
return true;
}
return false;
}
public int getAño() {
return año;
}
}
public class MainF {

final Fecha f;
f= new Fecha();
f.setDia(10);
f.setMes(3);
f.setAño(2001);
System.out.println(f.getDia()+"/"+f.getMes()+"/"+f.getAño(
));
f= new Fecha(); //Error: la variable f es final y no
puede ser reasignada
}
}
Objetos constantes en Ruby
Los objetos constantes ya fueron indirectamente explicados al mencionar el

manejo de constantes en Ruby, debido a que todos los datos son manejados como
objetos. Recordemos que deben empezar con una letra mayúscula y pueden ser
definidas dentro de una clase o módulo y serán visibles dentro de ese ámbito. Una
constante definida fuera de un clase o módulo será vista globalmente. Es posible
reasignar un valor a una constante, pero esto producirá una advertencia (pero no
un error).
- 173 -
Ejemplo:
class Fecha
def initialize
@dia= @mes =1
@anio=1900
end
def setDia dia

if dia>=1 && dia<=31
@dia=dia
return true
end
return false
end
def setMes mes

if mes>=1 && mes<=12
@mes=mes
return true
end
return false
end
def setAnio a
if a>=1900
@anio=a
return true
end
return false
end
attr_reader :dia, :mes, :anio

end
#Código de prueba
Fe = Fecha.new # es constante por ser nombrada con una

mayúscula como prefijo

- 174 -
Fe.setDia 10
Fe.setMes 3
Fe.setAnio 2008
puts Fe.dia.to_s+"/"+Fe.mes.to_s+"/"+Fe.anio.to_s
# ó:
puts "#{Fe.dia}/#{Fe.mes}/#{Fe.anio}"
Fe=Fecha.new # genera un warning pero no es un error al ser

reasignado el identificador constante

- 175 -
Funciones amigas en C++
En C++ existe la amistad. Aunque algunos la consideran como una

intrusión a la encapsulación o a la privacidad de los datos:
"... la amistad corrompe el ocultamiento de información y debilita el valor del

enfoque de diseño orientado a objetos" [11]
Un amigo de una clase es una función u otra clase que no es miembro de la

clase, pero que tiene permiso de usar los miembros públicos y privados de la
clase.
Es importante señalar que el ámbito de una función amiga no es el de la
clase, y por lo tanto los amigos no son llamados con los operadores de acceso de
miembros.
Sintaxis para una función amiga:
class <nombreClase> {
friend <tipo> <metodo>();
...
public:
...
};
Sintaxis para una clase amiga:
class <nombreClase> {
friend <nombreClaseAmiga>;
...
public:
...
};

- 176 -
Las funciones o clases amigas no son privadas ni públicas (o protegidas),

pueden ser colocadas en cualquier parte de la definición de la clase, pero se
acostumbra que sea al principio.
Como la amistad entre personas, esta es concedida y no tomada. Si la clase

B quiere ser amigo de la clase A, la clase A debe declarar que la clase B es su
amiga.
La amistad no es simétrica ni transitiva: si la clase A es un amigo de la

clase B, y la clase B es un amigo de la clase C, no implica:
• Que la clase B sea un amigo de la clase A.
• Que la clase C sea un amigo de la clase B.
• Que la clase A sea un amigo de la clase C.
Ejemplo 1:
//Ejemplo de funcion amiga con acceso a miembros privados
#include <iostream>
class ClaseX{
friend void setX(ClaseX &, int); //declaración friend
public:
ClaseX(){
x=0;
}
void print() const {
cout<<x<<endl;
}
private:
int x;
};

- 177 -
void setX(ClaseX &c, int val){

c.x=val; //es legal el acceso a miebros privados por
amistad.
}
int main(){
ClaseX pr;
cout<<"pr.x después de instanciación : ";

pr.print();
cout<<"pr.x después de la llamada a la función amiga setX
: ";
setX(pr, 10);
pr.print();
}
Ejemplo 2:
//ejemplo 2 de funciones amigas

#include <iostream>
class Linea;
class Recuadro {
friend int mismoColor(Linea, Recuadro);
private:
int color; //color del recuadro
int xsup, ysup; //esquina superior izquierda
int xinf, yinf; //esquina inferior derecha
public:
void ponColor(int);
void definirRecuadro(int, int, int, int);
};

- 178 -
class Linea{
friend int mismoColor(Linea, Recuadro);
private:
int color;
int xInicial, yInicial;
int lon;
public:
void ponColor(int);
void definirLinea(int, int, int);
};
int mismoColor(Linea l, Recuadro r){

if(l.color==r.color)
return 1;
return 0;
}
//métodos de la clase Recuadro

void Recuadro::ponColor(int c) {
color=c;
}
void Recuadro::definirRecuadro(int x1, int y1, int x2, int y2)

{
xsup=x1;
ysup=y1;
xinf=x2;
yinf=y2;
}
//métodos de la clase Linea

void Linea::ponColor(int c) {
color=c;
}
void Linea::definirLinea(int x, int y, int l) {

xInicial=x;
yInicial=y;

- 179 -
lon=l;
}
int main(){
Recuadro r;
Linea l;
r.definirRecuadro(10, 10, 15, 15);

r.ponColor(3);
l.definirLinea(2, 2, 10);
l.ponColor(4);
if(!mismoColor(l, r))
cout<<"No tienen el mismo color"<<endl;
//se ponen en el mismo color

l.ponColor(3);
if(mismoColor(l, r))
cout<<"Tienen el mismo color";
return 0;
}

- 180 -
Sobrecarga de operadores en C++
C++ no permite la creación de nuevos operadores, pero si permite en

cambio sobrecargar los operadores existentes para que se utilicen con los objetos.
De esta forma se les da a los operadores un nuevo significado de acuerdo al
objeto sobre el cual se aplique.
Para sobrecargar un operador, se define un método que es invocado cuando

el operador es aplicado sobre ciertos tipos de datos.
Para utilizar un operador con objetos, es necesario que el operador este

sobrecargado, aunque existen dos excepciones:
El operador de asignación =, puede ser utilizado sin sobrecargarse

explícitamente, pues el comportamiento por omisión es una copia a nivel de
miembro de los miembros de la clase. Sin embargo no debe de usarse si la
clase cuenta con miembros a los que se les asigne memoria de manera
dinámica.
El operador de dirección &, esta sobrecargado por omisión para devolver la

dirección de un objeto de cualquier clase.
Algunas restricciones:
1. Operadores que no pueden ser sobrecargados:
. .* :: ?: sizeof
2. La precedencia de un operador no puede ser modificada. Deben usarse los

paréntesis para obligar un nuevo orden de evaluación.
3. La asociatividad de un operador no puede ser modificada.

- 181 -
4. No se puede modificar el número de operandos de un operador. Los operadores

siguen siendo unarios o binarios.
5. No es posible crear nuevos operadores.
6. No puede modificarse el comportamiento de un operador sobre tipos de datos

definidos por el lenguaje.
La sintaxis para definir un método con un operador difiere de la definición

normal de un método, pues debe indicarse el operador seguido de la palabra
reservada operator :
<tipo> operator <operador> (<argumentos>) ;
<tipo> operator <operador> (<argumentos>) {

<cuerpo del método>
}
Para la definición fuera de la clase:
<tipo> <clase>::operator <operador> (<argumentos>) {

<cuerpo del método>
}

- 182 -
Ejemplo:
//programa de ejemplo de sobrecarga de operadores.
class Punto {
float x, y;
public:
Punto(float xx=0, float yy=0){
x=xx;
y=yy;
}
float magnitud();
Punto operator =(Punto);
Punto operator +(Punto);
Punto operator -();
Punto operator *(float);
Punto operator *=(float);
Punto operator ++(); //prefijo
Punto operator ++(int); //posfijo
int operator >(Punto);

int operator <=(Punto);
};
Punto Punto::operator =(Punto a){ //copia o asignación

x=a.x;
y=a.y;
return *this;
}
Punto Punto::operator +(Punto p){

return Punto(x+p.x, y+p.y);
}

- 183 -
Punto Punto::operator -(){

return Punto(-x, -y);
}
Punto Punto::operator *(float f){

Punto temp;
temp=Punto(x*f, y*f);
return temp;
}
// incremento prefijo
Punto Punto::operator ++(){
x++;
y++;
return *this;
}
// incremento posfijo
Punto Punto::operator++(int)
{
Punto temp= *this;
x++;
y++;
return temp;
}
int Punto::operator >(Punto p){

return (x>p.x && y>p.y) ? 1 : 0;
}
int Punto::operator <=(Punto p){

return (x<=p.x && y<=p.y) ? 1 : 0;
}
int main(){
Punto a(1,1);
Punto b;
Punto c;
b++;

- 184 -
++b;
c=b;
c=a+b;
c=-a;
c=a*.5;
return 0;
}

- 185 -
Ejercicio : Crear una clase String para el manejo de cadenas. Tendrá dos
atributos: apuntador a carácter y un entero tam, para almacenar el tamaño de la
cadena. Sobrecargar operadores = (asignación) e (==) igualdad. Usar un
programa de prueba.
La estructura será la siguiente:
class String{
char *s;
int tam;
public:
String(char *=NULL);
String(const String &copia); //constructor de copia
~String();
//sobrecarga de constructor de asignación
const String &operator =(const String &);
//igualdad
int operator ==(const String &) const ;
};
Véase que es posible asignar una cadena " " sin sobrecargar el operador de
asignación, o comparar un objeto String con una cadena. Esto se logra gracias a
que se provee de un constructor que convierte una cadena a un objeto String. De
esta manera, este constructor de conversión es llamado automáticamente, creando
un objeto temporal para ser comparado con el otro objeto.
No es posible que la cadena (o apuntador a char) vaya del lado izquierdo,

pues se estaría llamando a la funcionalidad del operador para un apuntador a
char.

- 186 -
Ejemplo: código de String:
//Sobrecarga de operadores. Implementación de una clase String

#include <iostream>
#include <stdio.h>
#include <string.h>
class String{
//operadores de inserción y extracción de flujo
friend ostream &operator << (ostream &, const String &);
friend istream &operator >> (istream &, String &);
private:
char *s;
int tam;
public:
String(char * =NULL);
String(const String &copia){

s=NULL;
tam=0;
*this=copia;//¿se vale o no?
}
~String(){
if(s!=NULL)
delete []s;
}
//sobrecarga de constructor de asignación

const String &operator =(const String &);
//igualdad
int operator ==(const String &) const ;
//concatenación
String operator +(const String &);
//concatenación y asignación
const String &operator +=(const String &);

- 187 -
String &copia (const String &);
//sobrecarga de los corchetes

char &operator[] (int);
};
//operadores de inserción y extracción de flujo

ostream& operator<< (ostream &salida, const String &cad){
salida<<cad.s;
return salida; //permite concatenación
}
istream &operator >> (istream &entrada, String &cad){

char tmp[100];
entrada >> tmp;
cad=tmp; //usa operador de asignación de String y const. de
conversión
return entrada; //permite concatenación
}
String::String(char *c){
if(c==NULL){
s=NULL;
tam=0;
} else {
tam=strlen(c);
s= new char[tam+1];
strcpy(s, c);
}
}
const String &String::operator =(const String &c){

if(this!= &c) { //verifica no asignarse a si mismo
if(s!=NULL)
delete []s;
tam=c.tam;
s= new char[tam+1];
strcpy(s, c.s);
}

- 188 -
return *this; //permite concatenación de asignaciones

}
int String::operator ==(const String &c)const {

return strcmp(s, c.s)==0;
}
//operador de suma regresa una copia de la suma obtenida

//en un objeto local.
String String::operator +(const String &c){
String tmp(*this);
tmp+=c;
return tmp;
}
const String &String::operator +=(const String &c){

char *str=s, *ctmp= new char [c.tam+1];
strcpy(ctmp, c.s);
tam+=c.tam;
s= new char[tam+1];
strcpy(s, str);
strcat(s, ctmp);
delete []str;
delete []ctmp;
return *this;
}
String &String::copia (const String &c){

if(this!= &c) { //verifica no asignarse a si mismo
if(s!=NULL)
delete []s;
tam=c.tam;
s= new char[tam+1];
strcpy(s, c.s);
}
return *this; //permite concatenación de asignaciones
}
char &String::operator[] (int i){

if(i>0 && i<tam)

- 189 -
return s[i];
return s[0];
}
int main(){
String a("AAA");
String b("Prueba de cadena");
String c(b);
/*es un error hacer una asignación sin liberar memoria.
ese es el principal peligro de usar el operador
sobrecargado por default de asignación*/
a=b;
b.copia("H o l a");
b=c+c;
b="nueva";
c+=c;
String d("nueva cadena");
d+="Hola";
String e;
e=d+"Adios";
d="coche";
int x=0;
x=d=="coche"; //Lo contrario no es válido "coche"==d
char ch;
ch=d[7];
d[2]=’X’;
cout<<d<<endl;
cout<<"Introduce dos cadenas:";
cin>>e>>d;
cout<<"Cadenas:\n";
cout<<e<<endl<<d;
return 0;
}

- 190 -
Sobrecarga de operadores en Ruby
Aunque Ruby no maneja sobrecarga de operaciones si soporta la sobrecarga de

operadores. Para hacerlo simplemente se define un método en la clase, donde el
nombre del método es el nombre del operador que se necesita sobrecargar.
Sintaxis:
def <operador>
...
end
Operadores que no pueden ser sobrecargados:
=, !, not, &&, and, ||, or, ., !=, .., ..., ::
La instrucción return puede omitirse en Ruby porque regresa el resultado de la

ultima expresion de una función.
Ejemplo:
#programa de ejemplo de sobrecarga de operadores.

class Punto
attr_reader :x, :y
@x
@y
def initialize x=10, y=10
@x, @y=x,y
end
def + op
return Punto.new(@x+op.x, @y+op.y)
end
def - (op)
Punto.new(@x-op.x, @y-op.y)
end
- 191 -
def * (f)
temp=Punto.new @x*f, @y*f
return temp
end
def > (op)

return (x>p.x && y>p.y) ? true : false
end
def <= (op)

return (x<=p.x && y<=p.y) ? true : false
end
end
def prueba
a= Punto.new 1,1
b= Punto.new
c= Punto.new
puts a.x
puts b.x
puts c.x
c=a+b
puts c.x
puts c.y
c+=a
puts c.x
puts c.y
c=a*0.5
puts c.x
puts c.y
end
prueba
Al ser un lenguaje dinámico, el segundo operando queda determinado en tiempo

de ejecución. Además al sobrecargar, por ejemplo, el operador + automáticamente
queda sobrecargado el operador += (lo mismo para el resto de las asigmaciones
abreviadas).
- 192 -
Herencia en C++
Introducción
La herencia es un mecanismo potente de abstracción que permite compartir

similitudes entre clases manteniendo al mismo tiempo sus diferencias.
Es una forma de reutilización de código, tomando clases previamente

creadas y formando a partir de ellas nuevas clases, heredándoles sus atributos y
métodos. Las nuevas clases pueden ser modificadas agregándoles nuevas
características.
En C++ la clase de la cual se toman sus características se conoce como clase

base; mientras que la clase que ha sido creada a partir de la clase base se conoce
como clase derivada. Existen otros términos para estas clases:
Clase base Clase derivada

Superclase Subclase
Clase padre Clase hija
En Java es más común usar el término de superclase y subclase.
Una clase derivada es potencialmente una clase base, en caso de ser

necesario.
Cada objeto de una clase derivada también es un objeto de la clase base. En

cambio, un objeto de la clase base no es un objeto de la clase derivada.
La implementación de herencia a varios niveles forma un árbol jerárquico

similar al de un árbol genealógico. Esta es conocida como jerarquía de herencia.

- 193 -
Generalización. Una clase base o superclase se dice que es más general que
la clase derivada o subclase.
Especialización. Una clase derivada es por naturaleza una clase más

especializada que su clase base.
Implementación en C++
La herencia en C++ es implementada permitiendo a una clase incorporar a

otra clase dentro de su declaración.
Sintaxis general:
class <claseNueva>: <acceso> <claseBase> {

//cuerpo clase nueva
};
Ejemplo:
Una clase vehículo que describe a todos aquellos objetos

vehículos que viajan en carreteras. Puede describirse a partir
del número de ruedas y de pasajeros.
De la definición de vehículos podemos definir objetos más

específicos (especializados). Por ejemplo la clase camión.
//ejemplo 01 de herencia
#include <iostream>
class Vehiculo{
int ruedas;
int pasajeros;
public:
void setRuedas(int);
int getRuedas();

- 194 -
void setPasajeros(int);
int getPasajeros();
};
void Vehiculo::setRuedas(int num){

ruedas=num;
}
int Vehiculo::getRuedas(){
return ruedas;
}
void Vehiculo::setPasajeros(int num){

pasajeros=num;
}
int Vehiculo::getPasajeros(){
return pasajeros;
}
//clase Camion con herencia de Vehículo

class Camion: public Vehiculo {
int carga;
public:
void setCarga(int);
int getCarga();
void muestra();
};
void Camion::setCarga(int num){

carga=num;
}
int Camion::getCarga(){
return carga;
}
void Camion::muestra(){
cout<<"Ruedas: "<< getRuedas()<<endl;
cout<<"Pasajeros: "<< getPasajeros()<<endl;

- 195 -
cout<<"Capacidad de carga: "<<getCarga()<<endl;

}
int main(){
Camion ford;
ford.setRuedas(6);
ford.setPasajeros(3);
ford.setCarga(3200);
ford.muestra();
return 0;
}
Control de Acceso a miembros en C++
Existen tres palabras reservadas para el control de acceso: public, private y

protected. Estas sirven para proteger los miembros de la clase en diferentes
formas.
El control de acceso, como ya se vio anteriormente, se aplica a los métodos,

atributos, constantes y tipos anidados que son miembros de la clase.
Resumen de tipos de acceso:
Tipo de Descripción
acceso
private Un miembro privado únicamente puede ser utilizado por
los métodos miembro y funciones amigas27 de la clase
donde fue declarado.
protected Un miembro protegido puede ser utilizado únicamente
por los métodos miembro y funciones amigas de la clase
donde fue declarado o por los métodos miembro y
funciones amigas de las clases derivadas.
27
Funciones amiga es un tema que se verá más adelante.
- 196 -
El acceso protegido es como un nivel intermedio entre el

acceso privado y público.
public Un miembro público puede ser utilizado por cualquier
método. Una estructura es considerada por C++ como
una clase que tiene todos sus miembros públicos.
Ejemplo:
//ejemplo de control de acceso
class S{
char *f1();
int a;
protected:
int b;
int f2();
private:
int c;
int f3();
public:
int d, f;
char *f4(int);
};
int main(){
S obj;
obj.f1(); //error
obj.a=1; //error
obj.f2();//error
obj.b=2; //error
obj.c=3; //error
obj.f3(); //error
obj.d=5;
obj.f4(obj.f);
return 0;
}

- 197 -
Control de acceso en herencia en C++
Hasta ahora se ha usado la herencia con un solo tipo de acceso, utilizando el

especificador public. Los miembros públicos de la clase base son miembros
públicos de la clase derivada, los miembros protegidos permanecen protegidos
para la clase derivada.
Ejemplo:
//ejemplo de control de acceso en herencia
class Base{
int a;
protected:
int b;
public:
int c;
};
class Derivada: public Base {

void g();
};
void Derivada::g(){
a=0; //error, es privado
b=1; //correcto, es protegido
c=2; //correcto, es público
}
Para accesar a los miembros de una clase base desde una clase derivada, se
pueden ajustar los permisos por medio de un calificador public, private o
protected.
Si una clase base es declarada como pública de una clase derivada, los
miembros públicos y protegidos son accesibles desde la clase derivada, no así los
miembros privados.

- 198 -
Si una clase base es declarada como privada de otra clase derivada, los
miembros públicos y protegidos de la clase base serán miembros privados de la
clase derivada. Los miembros privados de la clase base permanecen inaccesibles.
Si se omite el calificador de acceso de una clase base, se asume por omisión

que el calificador es public en el caso de una estructura y private en el caso de
una clase.
Ejemplo de sintaxis:
class base {
...
};
class d1: private base {

...
};
class d2: base {

...
};
class d3: public base {

...
};
Es recomendable declarar explícitamente la palabra reservada private al

tomar una clase base como privada para evitar confusiones:
class x{
public:
F();
};
class y: x { //privado por omisión

...
};

- 199 -
void g( y *p){
p->f(); //error
}
Finalmente, si una clase base es declarada como protegida de una clase

derivada, los miembros públicos y protegidos de la clase base, se convierten en
miembros protegidos de la clase derivada.
Ejemplo:
//acceso por herencia

#include <iostream>
class X{
protected:
int i;
int j;
public:
void preg_ij();
void pon_ij();
};
void X::preg_ij() {
cout<< "Escriba dos números: ";
cin>>i>>j;
}
void X::pon_ij() {
cout<<i<<' '<<j<<endl;
}
//en Y, i y j de X siguen siendo miembros protegidos

//Si se llegara a cambiar este acceso a private i y j se
heredarian como
// miembros privados de Y, además de los métodos públicos
class Y: public X{
int k;
- 200 -
public:
int preg_k();
void hacer_k();
};
int Y:: preg_k(){

return k;
}
void Y::hacer_k() {
k=i*j;
}
// Z tiene acceso a i y j de X, pero no a k de Y

// porque es private por omisión
// Si Y heredara de x como private, i y j serían privados en
Y,
// por lo que no podrían ser accesados desde Z
class Z: public Y {
public:
void f();
};
// Si Y heredara a X con private, este método ya no

funcionaría
// no se podría acceder a i ni a j.
void Z::f() {
i=2;
j=3;
}
// si Y hereda de x como private, no es posible accesar a los

métodos
//públicos desde objetos de Y ni de Z.
int main() {
Y var;
Z var2;
var.preg_ij();
var.pon_ij();

- 201 -
var.hacer_k();
cout<<var.preg_k()<<endl;
var2.f();
var2.pon_ij();
return 0;
}
Manejo de objetos de la clase base como objetos de una clase derivada y

viceversa en C++
Un objeto de una clase derivada pública, puede ser manejado como un

objeto de su clase base. Sin embargo, un objeto de la clase base no es posible
tratarlo de forma automática como un objeto de clase derivada.
La opción que se puede utilizar, es enmascarar un objeto de una clase base a

un apuntador de clase derivada. El problema es que no debe ser desreferenciado
(accesado) así, primero se tiene que hacer que el objeto sea referenciado por un
apuntador de su propia clase.
Si se realiza la conversión explícita de un apuntador de clase base - que

apunta a un objeto de clase base- a un apuntador de clase derivada y,
posteriormente, se hace referencia a miembros de la clase derivada, es un error
pues esos miembros no existen en el objeto de la clase base.
Ejemplo :
// POINT.H
// clase Point
#ifndef POINT_H_
#define POINT_H_

- 202 -
class Point {
friend ostream &operator<<(ostream &, const Point &);
public:
Point(float = 0, float = 0);
void setPoint(float, float);
float getX() const { return x; }
float getY() const { return y; }
protected:
float x, y;
};
#endif /*POINT_H_*/
// POINT.CPP
#include <iostream>
#include "point.h"
Point::Point(float a, float b){

x = a;
y = b;
}
void Point::setPoint(float a, float b){

x = a;
y = b;
}
ostream &operator<<(ostream &output, const Point &p){

output << '[' << p.x << ", " << p.y << ']';
return output;
}

- 203 -
// CIRCLE.H
// clase Circle
#ifndef CIRCLE_H
#define CIRCLE_H
#include <iostream>
#include <iomanip.h>
#include "point.h"
class Circle : public Point { // Circle hereda de Point

friend ostream &operator<<(ostream &, const Circle &);
public:
Circle(float r = 0.0, float x = 0, float y = 0);
void setRadius(float);
float getRadius() const;
float area() const;
protected:
float radius;
};
#endif /*CIRCLE_H_*/
// CIRCLE.CPP
#include "circle.h"
Circle::Circle(float r, float a, float b)

: Point(a, b) // llama al constructor de la clase base
{ radius = r; }
void Circle::setRadius(float r) { radius = r; }
float Circle::getRadius() const { return radius; }
float Circle::area() const

{ return 3.14159 * radius * radius; }
// salida en el formato:
// Center = [x, y]; Radius = #.##

- 204 -
ostream &operator<<(ostream &output, const Circle &c){

output << "Center = [" << c.x << ", " << c.y
<< "]; Radius = " << setiosflags(ios::showpoint)
<< setprecision(2) << c.radius;
return output;
}
//Prueba.cpp
// Probando apuntadores a clase base a apuntadores a clase
derivada
#include <iostream>
#include "point.h"
#include "circle.h"
int main(){
Point *pointPtr, p(3.5, 5.3);
Circle *circlePtr, c(2.7, 1.2, 8.9);
cout << "Point p: " << p << "\nCircle c: " << c << endl;
// Maneja a un Circle como un Circle

pointPtr = &c; // asigna la direccion de Circle a
pointPtr
circlePtr = (Circle *) pointPtr; // mascara de base a
derivada
cout << "\nArea de c (via circlePtr): "
<< circlePtr->area() << endl;
// Es riesgoso manejar un Point como un Circle

// getRadius() regresa basura
pointPtr = &p; // asigna direccion de Point a pointPtr
circlePtr = (Circle *) pointPtr; // mascara de base a
derivada
cout << "\nRadio de objeto apuntado por circlePtr: "
<< circlePtr->getRadius() << endl;
return 0;
}

- 205 -
Constructores de clase base en C++
El constructor de la clase base puede ser llamado desde la clase derivada,

para inicializar los atributos heredados.
Los constructores y operadores de asignación de la clase base no son

heredados por las clases derivadas. Pero pueden ser llamados por los de la clase
derivada.
Un constructor de la clase derivada llama primero al constructor de la clase

base. Si se omite el constructor de la clase derivada, el constructor por omisión de
la clase derivada llamará al constructor de la clase base.
Los destructores son llamados en orden inverso a las llamadas del

constructor: un destructor de una clase derivada será llamado antes que el de su
clase base.
Sintaxis:
<clase>::<constructor>(<lista de argumentos>) : <contructor de

clase base>(<lista de argumentos sin el tipo>)
Ejemplo:
// POINT.H
#ifndef POINT_H
#define POINT_H
class Point {
public:
Point(float = 0.0, float = 0.0);
~Point();
protected:
float x, y;
};

- 206 -
#endif /*POINT_H_*/
// POINT.CPP
#include <iostream>
#include "point.h"
Point::Point(float a, float b){
x = a;
y = b;
cout << "Constructor Point: "

<< '[' << x << ", " << y << ']' << endl;
}
Point::~Point(){
cout << "Destructor Point: "
<< '[' << x << ", " << y << ']' << endl;
}
// CIRCLE.H
#ifndef CIRCLE_H
#define CIRCLE_H
#include "point.h"
class Circle : public Point {

public:
Circle(float r = 0.0, float x = 0, float y = 0);
~Circle();
private:
float radius;
};
#endif /*CIRCLE_H_*/
// CIRCLE.CPP
#include "circle.h"

- 207 -

: Point(a, b) // llamada al constructor de clase base
{
radius = r;
cout << "Constructor Circle: radio es "

<< radius << " [" << a << ", " << b << ']' << endl;
}
Circle::~Circle(){
cout << "Destructor Circle: radio es "
<< radius << " [" << x << ", " << y << ']' << endl;
}
// Main.CPP
#include <iostream.h>
#include "point.h"
#include "circle.h"
int main(){
// Muestra llamada a constructor y destructor de Point
{
Point p(1.1, 2.2);
}
cout << endl;

Circle circle1(4.5, 7.2, 2.9);
cout << endl;
Circle circle2(10, 5, 5);
cout << endl;
return 0;
}

- 208 -
Redefinición de métodos en C++
Algunas veces, los métodos heredados no cumplen completamente la

función que quisiéramos que realicen en las clases derivadas. Es posible en C++
redefinir un método de la clase base en la clase derivada. Cuando se hace
referencia al nombre del método, se ejecuta le versión de la clase en donde fue
redefinida.
Es posible sin embargo, utilizar el método original de la clase base por

medio del operador de resolución de alcance.
Se sugiere redefinir métodos que no vayan a ser empleados en la clase

derivada, inclusive sin código para inhibir cualquier acción que no nos interese28.
La redefinición de métodos no es una sobrecarga porque se definen exactamente

con la misma firma.
Ejemplo :
// EMPLOY.H
#ifndef EMPLOY_H
#define EMPLOY_H
class Employee {
public:
Employee(const char*, const char*);
void print() const;
~Employee();
private:
char *firstName;
char *lastName;
};
28
En teoría esto no debería ser necesario anular operaciones si nos apegamos a la regla del 100% (de
conformidad con la definición)
- 209 -
#endif /*EMPLOY_H_*/
// EMPLOY.CPP
#include <string.h>
#include <iostream>
#include <assert.h>
#include "employ.h"
Employee::Employee(const char *first, const char *last){

firstName = new char[ strlen(first) + 1 ];
assert(firstName != 0); strcpy(firstName, first);
lastName = new char[ strlen(last) + 1 ];

assert(lastName != 0);
strcpy(lastName, last);
}
void Employee::print() const

{ cout << firstName << ' ' << lastName; }
Employee::~Employee(){
delete [] firstName;
delete [] lastName;
}
// HOURLY.H
#ifndef HOURLY_H
#define HOURLY_H
#include "employ.h"
class HourlyWorker : public Employee {

public:
HourlyWorker(const char*, const char*, float, float);
float getPay() const;
void print() const;
private:
float wage;
float hours;

- 210 -
};
#endif /*HOURLY_H_*/
// HOURLY_B.CPP
#include <iostream>
#include "hourly.h"
HourlyWorker::HourlyWorker(const char *first, const char

*last, float initHours, float initWage) : Employee(first,
last) {
hours = initHours;
wage = initWage;
}
float HourlyWorker::getPay() const { return wage * hours; }
void HourlyWorker::print() const {

cout << "HourlyWorker::print()\n\n";
Employee::print(); // llama a función de clase base
cout << " es un trabajador por hora con sueldo de"

<< " $" << setiosflags(ios::showpoint)
<< setprecision(2) << getPay() << endl;
}
// main.CPP
#include <iostream>
#include "hourly.h"
int main(){
HourlyWorker h("Bob", "Smith", 40.0, 7.50);
h.print();
return 0;
}

- 211 -
Herencia Múltiple en C++
Una clase puede heredar miembros de más de una clase; lo que se conoce
como herencia múltiple.
Herencia múltiple es entonces, la capacidad de una clase derivada de

heredar miembros de varias clases base.
Sintaxis:
class <nombre clase derivada> : <clase base 1> , <clase base

2>, ...<clase base n> {
...
};
Ejemplo:
class A{
public:
int i;
void a(){}
};
class B{
public:
int j;
void b(){}
};
class C{
public:
int k;
void c(){}
};

- 212 -
class D: public A, public B, public C {

public:
int l;
void d(){}
};
int main() {
D var1;
var1.a();
var1.b();
var1.c();
var1.d();
return 0;
}
Otro ejemplo :
// BASE1.H
#ifndef BASE1_H
#define BASE1_H
class Base1 {
public:
Base1(int x) { value = x; }
int getData() const { return value; }
protected:
int value;
};
#endif /*BASE1_H_*/

- 213 -
// BASE2.H
#ifndef BASE2_H
#define BASE2_H
class Base2 {
public:
Base2(char c) { letter = c; }
char getData() const { return letter; }
protected:
char letter;
};
#endif /*BASE2_H_*/
// DERIVED.H
#ifndef DERIVED_H
#define DERIVED_H
// herencia múltiple
class Derived : public Base1, public Base2 {
friend ostream &operator<<(ostream &, const Derived &);
public:
Derived(int, char, float);
float getReal() const;
private:
float real;
};
#endif /*DERIVED_H_*/
// DERIVED.CPP
#include "base1.h"
#include "base2.h"
#include "derived.h"
Derived::Derived(int i, char c, float f): Base1(i), Base2(c) {

real = f;
}

- 214 -
float Derived::getReal() const {

return real;
}
ostream &operator<<(ostream &output, const Derived &d) {

output << " Entero: " << d.value
<< "\n Caracter: " << d.letter
<< "\nNúmero real: " << d.real;
return output;
}
// main.CPP
#include "base1.h"
#include "base2.h"
#include "derived.h"
int main(){
Base1 b1(10), *base1Ptr; Base2 b2('Z'), *base2Ptr;
Derived d(7, 'A', 3.5);
cout << "Objeto b1 contiene entero "
<< b1.getData()
<< "\nObjeto b2 contiene caracter "
<< b2.getData()
<< "\nObjeto d contiene:\n" << d;
cout << "\n\nmiembros de clase derivada pueden ser"
<< " accesados individualmente:"
<< "\n Entero: " << d.Base1::getData()
<< "\n Caracter: " << d.Base2::getData()
<< "\n Número real: " << d.getReal() << "\n\n";
// Probar: cout<<d.getData(); Es un error?
cout << "Miembros derivados pueden ser tratados como "
<< "objetos de su clase base:\n";
base1Ptr = &d;
cout << "base1Ptr->getData() "
<< base1Ptr->getData();
base2Ptr = &d;

- 215 -
cout << "\nbase2Ptr->getData() "

<< base2Ptr->getData() << endl;
return 0;
}
Aquí se tiene un problema de ambigüedad al heredar dos métodos con el

mismo nombre de clases diferentes. Se resuelve poniendo antes del nombre del
miembro el nombre de la clase: objeto.<clase::>miembro. El nombre del objeto
es necesario pues no se esta haciendo referencia a un miembro estático.
Ambigüedades
En el ejemplo anterior se vio un caso de ambigüedad al heredar de clases

distintas un miembro con el mismo nombre. Normalmente se deben tratar de
evitar esos casos, pues vuelven confuso nuestra jerarquía de herencia.
Existen otro casos donde es posible que se de la ambigüedad.
Ejemplo:
//ejemplo de ambigüedad en la herencia

class B{
public:
int b;
};
class D: public B, public B { //error

};
void f( D *p) {
p->b=0; //ambiguo
}
int main(){
D obj;
f(&obj);
return 0;
}

- 216 -
El código anterior tiene un error en la definición de herencia múltiple, ya

que no es posible heredar más de una vez una misma clase de manera directa. Sin
embargo, si es posible heredar las características de una clase más de una vez
indirectamente:
//ejemplo de ambigüedad en la herencia

#include <iostream>
class A{
public:
int next;
};
class B: public A{
};
class C: public A{
};
class D: public B, public C {

int g();
};
int D::g(){

- 217 -
//next=0; Error: asignación ambigua

return B::next == C::next;
}
class E: public D{
public:
int x;
int getx(){
return x;
}
};
int main(){
D obj;
E obje;
obj.B::next=10;
obj.C::next=20;
// obj.A::next=11; Error: acceso ambiguo
// obj.next=22; Error: acceso ambiguo
cout<<"next de B: "<<obj.B::next<<endl;
cout<<"next de C: "<<obj.C::next<<endl;
obje.x=0;
obje.B::next=11;
obje.C::next=22;
cout<<"obje next de B: "<<obje.B::next<<endl;
cout<<"obje next de C: "<<obje.C::next<<endl;
return 0;
}
Este programa hace que las instancias de la clase D tengan objetos de clase
base duplicados y provoca los accesos ambiguos. Este problema se resuelve con
herencia virtual.
Herencia de clase base virtual: Si se especifica a una clase base como

virtual, solamente un objeto de la clase base existirá en la clase derivada.

- 218 -
Para el ejemplo anterior, las clases B y C deben declarar a la clase A como

clase base virtual:
class B: virtual public A {...}
class C: virtual public A {...}
El acceso entonces a los miembros puede hacerse usando una de las clases
de las cuales heredo el miembro:
obj.B::next=10;
obj.C::next=20;
O simplemente accediendolo como un miembro no ambiguo:
obj.next=22;
En cualquier caso se tiene solo una copia del miembro, por lo que cualquier
modificación del atributo next es sobre una única copia del mismo.

- 219 -
Constructores en herencia múltiple
Si hay constructores con argumentos, es posible que sea necesario llamarlos

desde el constructor de la clase derivada. Para ejecutar los constructores de las
clases base, pasando los argumentos, es necesario especificarlos después de la
declaración de la función de construcción de la clase derivada, separados por
coma.
Sintaxis general:
<Constructor clase derivada>(<argumentos> : <base1>
(<argumentos>), <base2> (<argumentos>), ... , <basen>
(<argumentos>) {
...
}
donde como en la herencia simple, el nombre base corresponde al nombre de la

clase, o en este caso, clases base.
El orden de llamada a constructores de las clases base se puede alterar a

conveniencia. Una excepción a considerar es cuando se recuelve ambigüedad de
una clase base pues en ese caso el constructor de la clase base ambigua
únicamente se ejecuta una vez. Si no es especificado por el programador, se
ejecuta el constructor sin parámetros de la clase base ambigua. Si se requiere
pasar parámetros, se debe especificar la llamada antes de las llamadas a
constructores de clase base directas. Este es el único caso en que es posible llamar
a un constructor de una clase que no es un ancestro directo [7].

- 220 -
Herencia en Java
La clase de la cual se toman sus características se conoce como superclase;

mientras que la clase que ha sido creada a partir de la clase base se conoce como
subclase.
Implementación en Java
La herencia en Java difiere ligeramente de la sintaxis de implementación de

herencia en C++.
Sintaxis general:
class claseNueva extends superclase {

//cuerpo clase nueva
}
Ejemplo:
Una clase vehículo que describe a todos aquellos objetos

vehículos que viajan en carreteras. Puede describirse a partir
del número de ruedas y de pasajeros.
De la definición de vehículos podemos definir objetos más

específicos (especializados). Por ejemplo la clase camión.
//ejemplo de herencia
class Vehiculo{
private int ruedas;
private int pasajeros;
public void setRuedas(int num){

ruedas=num;
}

- 221 -
public int getRuedas(){

return ruedas;
}
public void setPasajeros(int num){

pasajeros=num;
}
public int getPasajeros(){

return pasajeros;
}
//clase Camion con herencia de Vehiculo

public class Camion extends Vehiculo {
private int carga;
public void setCarga(int num){

carga=num;
}
public int getCarga(){

return carga;
}
public void muestra(){

// uso de métodos heredados
System.out.println("Ruedas: " + getRuedas());
System.out.println("Pasajeros: " + getPasajeros());
// método de la clase Camion
System.out.println("Capacidad de carga: " +
getCarga());
}
public static void main(String argvs[]){

Camion ford= new Camion();
ford.setRuedas(6);
ford.setPasajeros(3);
ford.setCarga(3200);

- 222 -
ford.muestra();
}
En el programa anterior se puede apreciar claramente como una clase

Vehículo hereda sus características a la subclase Camion, pudiendo este último
aprovechar recursos que no declara en su definición.
BlueJ
BlueJ es un programa desarrollado por la universidades de Kent y Deakin para

ayudar a los estudiantes a entender programación orientada a objetos en Java,
particularmente ayuda a entender la herencia.
A partir de un diagrama de clases, BlueJ puede generar el código básico de la

clase en Java, el cuál puede ser editado y compilado conforme las necesidades del
programa. El programa es básico y fácil de usar permitiendo entender estructuras
complejas en las relaciones de herencia.

- 223 -
El código Java generado por BlueJ para el diagrama de la figura anterior es el

siguiente:
/**
* Write a description of class Vehiculo here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Vehiculo
{
// instance variables - replace the example below with
your own
private int x;
/**
* Constructor for objects of class Vehiculo
*/
public Vehiculo()
{
// initialise instance variables
x = 0;
}
/**
* An example of a method - replace this comment with your
own
*
* @param y a sample parameter for a method
* @return the sum of x and y
*/
public int sampleMethod(int y)
{
// put your code here
return x + y;
}
}

- 224 -
/**
* Write a description of class Camion here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Camion extends Vehiculo
{
// instance variables - replace the example below with
your own
private int x;
/**
* Constructor for objects of class Camion
*/
public Camion()
{
// initialise instance variables
x = 0;
}
/**
* An example of a method - replace this comment with your
own
*
* @param y a sample parameter for a method
* @return the sum of x and y
*/
public int sampleMethod(int y)
{
// put your code here
return x + y;
}
}

- 225 -
Clase Object
En Java toda clase que se define tiene herencia implícita de una clase
llamada object. En caso de que la clase que crea el programador defina una
herencia explícita a una clase, hereda las características de la clase Object de
manera indirecta29.
A continuación se presenta la información general de la clase Object30:
Class Object
java.lang.Object
public class Object

Class Object is the root of the class hierarchy. Every class has Object as a superclass. All objects, including
arrays, implement the methods of this class.
Since:
JDK1.0
See Also:
Class
Constructor Summary
Object()
Method Summary
protected clone()
Object
Creates and returns a copy of this object.
boolean equals(Object obj)
Indicates whether some other object is "equal to" this one.
29
En este caso hay quye considerar que las características de la clase Object pudieron haber sido modificadas
a través de la jerarquía de herencia.
30
Tomada de la documentación del jdk 1.6
- 226 -
protected finalize()
void
Called by the garbage collector on an object when garbage
collection determines that there are no more references to the object.
Class<?> getClass()
Returns the runtime class of an object.
int hashCode()
Returns a hash code value for the object.
void notify()
Wakes up a single thread that is waiting on this object's monitor.
void notifyAll()
Wakes up all threads that are waiting on this object's monitor.
String toString()
Returns a string representation of the object.
void wait()
Causes current thread to wait until another thread invokes the
notify() method or the notifyAll() method for this object.
void wait(long timeout)
Causes current thread to wait until either another thread invokes
the notify() method or the notifyAll() method for this object, or a
specified amount of time has elapsed.
void wait(long timeout, int nanos)
Causes current thread to wait until another thread invokes the
notify() method or the notifyAll() method for this object, or some other
thread interrupts the current thread, or a certain amount of real time has
elapsed.
Control de acceso a miembros en Java
Existen tres palabras reservadas para el control de acceso a los miembros de

una clase: public, private y protected. Estas sirven para proteger los miembros de
la clase en diferentes formas.
El control de acceso, como ya se vio anteriormente, se aplica a los métodos,

atributos, constantes y tipos anidados que son miembros de la clase.

- 227 -
acceso
private Un miembro privado únicamente puede ser utilizado por
los métodos miembro de la clase donde fue declarado.
Un miembro privado no es posible que sea manejado ni
siquiera en sus subclases.
protected Un miembro protegido puede ser utilizado únicamente
por los métodos miembro de la clase donde fue
declarado, por los métodos miembro de las clases
derivadas ó clases que pertenecen al mismo paquete.
El acceso protegido es como un nivel intermedio entre el
acceso privado y público.
public Un miembro público puede ser utilizado por cualquier
método. Este es visible en cualquier lugar que la clase
sea visible
Ejemplo:
//ejemplo de control de acceso
class Acceso{
protected int b;
protected int f2() {
return b;
}
private int c;
private int f3() {
return c;
}
public int d, f;
public int f4(){
return d;
}

- 228 -
public class EjemploAcceso {
public static void main(String argvs[]){

Acceso obj= new Acceso();
obj.f2(); //es válido, ya que por omisión

obj.b=2; //las dos clases están en el mismo paquete
obj.c=3; //error es un atributo privado

obj.f3(); //error es un método privado
obj.d=5;
obj.f4();
}
}
El ejemplo anterior genera errores de compilación al tratar de acceder desde

otra clase a miembros privados. Sin embargo, los miembros protegidos si pueden
ser accesados porque están considerados implícitamente dentro del mismo
paquete.

- 229 -
Control de acceso de clase public en Java
Este controlador de acceso public, opera a nivel de la clase para que esta se
vuelva visible y accesible desde cualquier lugar, lo que permitiría a cualquier otra
clase hacer uso de los miembros de la clase pública.
public class TodosMeVen {
// definición de la clase
La omisión de este calificador limita el acceso a la clase para que solo sea
utilizada por clases pertenecientes al mismo paquete.
Además, se ha mencionado que en un archivo fuente únicamente puede

existir una clase pública, la cual debe coincidir con el nombre del archivo. La
intención es que cada clase que tenga un objetivo importante debería ir en un
archivo independiente, pudiendo contener otras clases no públicas que le ayuden
a llevar a cabo su tarea.
Constructores de superclase
Los constructores no se heredan a las subclases. El constructor de la

superclase puede ser llamado desde la clase derivada, para inicializar los atributos
heredados y no tener que volver a introducir código de inicialización ya escrito en
la superclase.
La llamada explícita al constructor de la superclase se realiza mediante la

referencia super seguida de los argumentos –si los hubiera- del constructor de la
clase base. La llamada a este constructor debe ser hecha en la primera línea del
constructor de la subclase. Si no se introduce así, el constructor de la clase

- 230 -
derivadada llamará automáticamente al constructor por omisión (sin parámetros)

de la superclase.
En el ejemplo siguiente podrá apreciarse esta llamada al constructor de la

superclase.
Manejo de objetos de la subclase como objetos de una superclase en Java
Un objeto de una clase derivada, puede ser manejado como un objeto de su

superclase. Sin embargo, un objeto de la clase base no es posible tratarlo como un
objeto de clase derivada.
Un objeto de una subclase puede ser asignado a una variable de referencia

de su superclase sin necesidad de indicar una conversión explícita mediante
enmascaramiento. Cuando si se necesita utilizar enmascaramiento es para asignar
de vuelta un objeto que aunque sea de una clase derivada, este referenciado por
una variable de clase base. Esta conversión explícita es verificada por la máquina
virtual, y si no corresponde el tipo real del objeto, no se podrá hacer la asignación
y se generará una excepción en tiempo de ejecución.
Ejemplo:
Superclase s= new superclase(), aptSuper;
Subclase sub= new subclase(), aptSub;
//válido
aptSuper = sub;
aptSub = (Subclase) aptSuper;
//inválido
aptSub= (Subclase) s;
Podemos ver en el ejemplo anterior, que un objeto puede “navegar” en la

jerarquía de clases hacia sus superclases, pero no puede ir a una de sus subclases,
- 231 -
ni utilizando el enmascaramiento. Esto se hace por seguridad, ya que la subclase

seguramente contendrá un mayor número de elementos que una instancia de
superclase y estos no podrían ser utilizados porque causarían una inconsistencia.
Por último, es importante señalar que mientras un objeto de clase derivada

este referenciado como un objeto de superclase, deberá ser tratado como si el
objeto fuera únicamente de la superclase; por lo que no podrá en ese momento
tener referencias a atributos o métodos definidos en la clase derivada.
Un ejemplo completo se muestra a continuación:

// definicion de clase point
public class Point {
protected double x, y; // coordenadas del punto
// constructor
public Point( double a, double b ) {
setPoint( a, b );
}
// asigna a x,y las coordenadas del punto

public void setPoint( double a, double b ) {
x = a;
y = b;
}
// obtiene coordenada x
public double getX() {
return x;
}
// obtiene coordenada y
public double getY() {
return y;
}
// convierte informacion a cadena

public String toString(){

- 232 -
return "[" + x + ", " + y + "]";

}
}
// Definicion de clase circulo
public class Circle extends Point { // Hereda de Point

protected double radius;
// constructor sin argumentos

public Circle() {
super( 0, 0 ); // llamada a constructor de clase base
setRadius( 0 );
}
// Constructor
public Circle( double r, double a, double b ) {
super( a, b ); // llamada a constructor de clase base
setRadius( r );
}
// Asigna radio del circulo

public void setRadius( double r )
{ radius = ( r >= 0.0 ? r : 0.0 ); }
// Obtiene radio del circulo

public double getRadius() { return radius; }
// Calculo area del circulo

public double area() { return 3.14159 * radius * radius; }
// Convierte informacion en cadena

public String toString() {
return "Centro = " + "[" + x + ", " + y + "]" +
"; Radio = " + radius;
}
}

- 233 -
// Clase de Prueba de las clases Point y Circle
public class Prueba {
public static void main( String argvs[] ) {

Point pointRef, p;
Circle circleRef, c;
p = new Point( 3.5, 5.3 );

c = new Circle( 2.7, 1.2, 8.9 );
System.out.println( "Punto p: " + p.toString() );

System.out.println( "Circulo c: " + c.toString());
// Tratamiento del circulo como instancia de punto

pointRef = c; // asigna circulo c a pointRef
// en realidad Java lo reconoce dinámicamente como
objeto Circle
System.out.println( "Circulo c (via pointRef): " +
pointRef.toString());
// Manejar a un circulo como circulo (obteniendolo de

una referencia de punto)
pointRef = c; // asigna circulo c a pointref. Se
repite la operacion por claridad
circleRef = (Circle) pointRef; // enmascaramiento de
superclase a subclase
System.out.println( "Circulo c (via circleRef): " +
circleRef.toString());
System.out.println( "Area de c (via circleRef): " +
circleRef.area());
// intento de referenciar a un objeto point

// desde una referencia de Circle (genera una excepcion)
circleRef = (Circle) p;
}
}

- 234 -
Redefinición de métodos
Algunas veces, los métodos heredados no cumplen completamente la

función que queremos que realicen en la subclase. Por esta razón, Java permite
redefinir un método de la clase base en la clase derivada. Cuando se hace
referencia al nombre del método, se ejecuta la versión de la clase en donde fue
redefinida. Es posible sin embargo, utilizar el método de la clase base por medio
del la referencia super.
De hecho, se sugiere redefinir métodos que no vayan a ser empleados en la

clase derivada, inclusive sin código para inhibir cualquier acción que no nos
interese en la clase derivada.
Ejemplo:
//clase empleado
public class Empleado {
private String firstName, lastName;
public Empleado(String first, String last){

firstName = new String(first);
lastName = new String(last);
}
public void print() {

System.out.println( firstName + ' ' + lastName);
}
//clase TrabajadorporHora
public class TrabajadorPorHora extends Empleado {
private float wage, hours;
public TrabajadorPorHora(String first, String last, float
initHours, float initWage) {
super(first, last);
hours = initHours;

- 235 -
wage = initWage;
}
public float getPay() {

return wage * hours;
}
public void print() {

System.out.println("Metodo print de Trabajador por
hora");
super.print(); // llama a función de clase base
System.out.println(" es un trabajador por hora con

sueldo de" +
" $" + getPay());
}
}
// clase de prueba EmpTest
public class EmpTest {
public static void main(String argvs[]) {

Empleado e= new Empleado ("nombre", "apellido");
TrabajadorPorHora h;
h=new TrabajadorPorHora ("Juanito", "Perez", 40.0f,

7.50f);
e.print();
h.print();
}
}

- 236 -
Calificador final
Es posible que tengamos la necesidad de que cierta parte de una clase no

pueda ser modificada en futuras extensiones de la jerarquía de herencia. Para esto
es posible utilizar el calificador final.
Si un método se especifica en una clase X como final:
<acceso> final <tipo> nombreMétodo( <parámetros>)
Se esta diciendo que el método no podrá ser redefinido en las subclases de

X.
Aunque se omita este calificador, si se trata de un método de clase (estático)

o privado, se considera final y no podrá ser redefinido.
Por otro lado, es posible que no queramos dejar la posibilidad de extender

una clase, para lo que se utiliza el calificador final a nivel de clase:
<acceso> final class nombreClase {
//definición de la clase
}
De esta forma, la clase no permite generar subclases a partir de ella. De
hecho, el API de Java incluye muchas clases final, por ejemplo la clase
java.lang.String no puede ser especializada.

- 237 -
Interfaces
Java únicamente cuenta con manejo de herencia simple, y la razón que se

ofrece es que la herencia múltiple presenta algunos problemas de ambigüedad que
complica el entendimiento del programa, sin que este tipo de herencia justifique
las ventajas obtenidas de su uso.
Sin embargo, es posible que se necesiten recibir características de más de un

origen. Java soluciona esto mediante el uso de interfaces, que son una forma para
declarar tipos especiales de clase que, aunque con ciertas limitaciones, no ofrecen
las complicaciones de la herencia múltiple.
Una interfaz tiene un formato muy similar a una clase, sus principales
características:
• Una interfaz proporciona los nombres de los métodos, pero no sus

implementaciónes.31
• Una clase puede implementar varias interfaces, aunque solo pueda heredar
una clase.
• No es posible crear instancias de una interfaz.
• La clase que implementa la interfaz debe escribir el código de todos los

métodos, de otra forma no se podrá generar instancias de esa clase.
El formato general para la declaración de una interfaz es el siguiente:
[public] interface <nombreInterfaz> {

//descripción de miembros
//los métodos no incluyen código:
<acceso> <tipo> <nombreMetodo> ( <parámetros> ) ;
}
31
En esta caso si se considera la declaración de prototipos.
- 238 -
El cuerpo de la interfaz generalmente es una lista de prototipos de métodos,

pero puede contener atributos si se requiere32.
Una clase implementa una interfaz a través de la palabra reservada

implements después de la especificación de la herencia (si la hubiera) :
class <nombreClase> extends <Superclase> implements

<nombreInterfaz> {
//definición de la clase
//debe incluirse la definición de los métodos de la
interfaz
//con la implementación del código de dichos métodos.
}
Además, una interfaz puede ser extendida de la misma forma que una clase,
aprovechando las interfaces previamente definidas, mediante el uso de la claúsula
extends.
[public] interface <nombreInterfaz> extends <InterfazBase> {
//descripción de miembros
De forma distinta a la jerarquía de clases, donde se tiene una jerarquía lineal

que parte siempre de una clase simple Object, una clase soporta herencia múltiple
de interfaces, resultando en una jerarquía con multiples raices de diferentes
interfaces.
Ejemplo:
//interfaz
interface IStack {
void push(Object item);
32
El parámetro debe incluir el nombre, el cual no es obligatorio que coincida en la implementación.
- 239 -
Object pop();
}
//clase implementa la interfaz

class StackImpl implements IStack {
protected Object[] stackArray;
protected int tos;
public StackImpl(int capacity) {

stackArray = new Object[capacity];
tos = -1;
}
//implementa el método definido en la interfaz

public void push(Object item)
{ stackArray[++tos] = item; }
//implementa el método definido en la interfaz

public Object pop() {
Object objRef = stackArray[tos];
stackArray[tos] = null;
tos--;
return objRef;
}
public Object peek() { return stackArray[tos];}

}
// extendiendo una interfaz

interface ISafeStack extends IStack {
boolean isEmpty();
boolean isFull();
}

- 240 -
//esta clase hereda la implementación de la pila StackImpl

// e implementa la nueva interfaz extendida ISafeStack
class SafeStackImpl extends StackImpl implements ISafeStack {
public SafeStackImpl(int capacity) { super(capacity); }
//implementa los métodos de la interfaz

public boolean isEmpty() { return tos < 0; }
public boolean isFull() { return tos >= stackArray.length;
}
}
public class StackUser {

SafeStackImpl safeStackRef = new SafeStackImpl(10);
StackImpl stackRef = safeStackRef;
ISafeStack isafeStackRef = safeStackRef;
IStack istackRef = safeStackRef;
Object objRef = safeStackRef;
safeStackRef.push("Dolar");
stackRef.push("Peso");
System.out.println(isafeStackRef.pop());
System.out.println(istackRef.pop());
System.out.println(objRef.getClass());
}
}

- 241 -
<<Interface>>
IStack Object
push()
pop()
StackImpl
push()
pop()
SafeStack
isFull()
isEmpty()
Por otro lado, una interfaz tambien puede ser utilizada para definir nuevos
tipos. Una interfaz así o una clase que implementa a una interfaz de este estilo es
conocida como Supertipo.
Es importante resaltar tres diferencias en las relaciones de herencia y como

esta funciona entre clases e interfaces:
1. Implementación lineal de jerarquía de herencia entre clases: una clase

extiende a otra clase.
2. Jerarquía de herencia múltiple entre interfaces: una interfaz extiende

otras interfaces.
3. Jerarquía de herencia múltiple entre interfaces y clases: una clase

implementa interfaces.

- 242 -
Herencia en Ruby
Implementación en Ruby
Ruby, al igual que Java, no cuenta con herencia múltiple, por lo que
únicamente es posible indicar una clase como superclase. Para esto se utiliza el
símbolo < antes del nombre de la superclase.
Sintaxis:
class IdentificadorClase < SuperClase

<expresión>
end
Ejemplo:
Retomando el ejemplo del la jerarquía de Vehículo y Camión, visto en la sección
de herencia en Java.
# ejemplo de herencia
class Vehiculo
@ruedas
@pasajeros
attr_accessor :ruedas, :pasajeros
end
# clase Camion con herencia de Vehiculo

class Camion < Vehiculo
@carga
attr_accessor :carga
public
def muestra
# uso de métodos heredados y generados automaticamente
por attr_accessor
puts "Ruedas: #{ruedas}"

- 243 -
puts "Pasajeros: #{pasajeros}"

# método de la clase Camion
puts "Capacidad de carga: #{carga}"
end
end
# Código de prueba
ford= Camion.new
ford.ruedas =6
ford.pasajeros=3
ford.carga=3200
ford.muestra
Clase Class
Las clases en Ruby son considerados objetos de primera clase33. Cada clase
declarada en Ruby es una instancia de la clase Class [12].
El proceso que se sigue es el siguiente: cuando una clase es definida, un objeto de

la clase Class es creado y asignado a una constante global con el nombre de usado
en la definición. Cuando un nuevo objeto de la clase es instanciado
(nombreClase.new), el método new de Class es ejecutado por omisión. 34
A continuación se presenta la información general de la clase Class [12]:
class methods
inherited aClass.inherited( aSubClass )
This is a singleton method (per class) invoked by Ruby when a subclass of
aClass is created. The new subclass is passed as a parameter.
class Top
def Top.inherited(sub)
print "New subclass: ", sub, "\n"
end
33
Pueden ser usados en el lengauje de programación como cualquier otro objeto.
34
De hecho, el método new de la clase Class puede ser redefinido, aunque no es una práctica recomendada.
- 244 -
end
class Middle < Top

end
class Bottom < Middle

end
produces:
New subclass: Middle

New subclass: Bottom
new Class.new( aSuperClass=Object ) -> aClass

Creates a new anonymous (unnamed) class with the given superclass (or
Object if no parameter is given).
instance methods
new aClass.new( [ args ]* ) -> anObject
Creates a new object of aClass's class, then invokes that object's initialize
method, passing it args.
superclass aClass.superclass -> aSuperClass or nil

Returns the superclass of aClass, or nil.
Class.superclass » Module
Object.superclass » nil
Clase Object
La clase padre de todas las clases en Ruby es la clase Object, por lo que sus
métodos están disponibles para todos los objetos a menos que estos se encuentren
redefinidos.
A contianuación se presenta una lista de los métodos de Object:

- 245 -
== === =~ __id__ __send__ class clone dclone

display dup enum_for eql? equal? extend freeze
frozen? hash id inspect instance_eval instance_of?
instance_variable_defined? instance_variable_get
instance_variable_get instance_variable_set
instance_variable_set instance_variables is_a? kind_of?
method methods new nil? object_id private_methods
protected_methods public_methods remove_instance_variable
respond_to? send singleton_method_added
singleton_method_removed singleton_method_undefined
singleton_methods taint tainted? to_a to_enum to_s
to_yaml to_yaml_properties to_yaml_style type untaint
Control de acceso a miembros en Ruby
Como ya se ha mencionado, también en Ruby existen tres palabras

reservadas para el control de acceso a los métodos de una clase: public, private y
protected. Estas sirven para proteger los métodos de la clase en diferentes formas.
acceso
private Un método privado bo puede ser llamado mediante un
objeto. Por esta razón, los métodos privados solo pueden
ser utilizados en la definición de la clase.
protected Un método protegido puede ser utilizado únicamente
por objetos de la clase donde se define el método, asi
como por sus subclases.
public Un método público puede ser utilizado por cualquier
método. Este es visible en cualquier lugar que la clase
sea visible. Los métodos son públicos por omisión, con
excepción del método initialize, el cual es privado.
- 246 -
La diferencia entre privado y protegido es diferente de los lenguajes C++ y Java.

En Ruby, un método protegido puede ser llamado por cualquier instancia de de la
clase donde se define o de sus subclases. Por su parte, un método privado puede
ser llamado solamente en el contexto un objeto de la clase. Los métodos privados
no puede ser ejecutados directamente ni siquiera por otro objeto de la misma clase
[12]. Ni siquiera el uso de self es válido para métodos privados.
Ejemplo:
class MiClase
def metodo1 # default es 'public'

#...
end
protected # subsecuentes metodos seran 'protected'
def metodo2 # 'protected'

#...
end
private # subsecuentes metodoss seran 'private'
def metodo3 # 'private'

#...
end
public # ssubsecuentes metodoss seran 'public'
def metodo4 # 'public'

#...
end
end
ó:
class MiClase

- 247 -
def metodo1
end
...
public :metodo1, :metodo4

protected :metodo2
private :metodo3
end

- 248 -
Inicializadores de superclase
En Ruby, de manera similar a Java, es posible llamar al método inicializador

de la superclase usando super seguido de la lista de argumentos.
Ejemplo:
class Persona
attr_accessor :nombre, :edad, :sexo
def initialize(nombre, edad, sexo)

@nombre, @edad, @sexo = nombre, edad, sexo
end
end
class Estudiante < Persona
attr_accessor :matr, :horas
def initialize(nombre, edad, sexo, matr, horas)

super(nombre, edad, sexo)
@matr = matr
@horas = horas
end
# ...
end
# Creando dos objetos

a = Persona.new("Ironman", 37, "m")
b = Estudiante.new("Spiderman", 36, "m", "000-13-5031", 24)

- 249 -
Manejo de objetos de la subclase como objetos de una superclase en Ruby
El manejo de objetos de subclase como objetos de superclase no es posible en

Ruby, debido a que los identificadores no tienen un tipo de dato
Ejemplo:
# definicion de clase point

class Point
attr_reader :x, :y
protected
@x
@y # coordenadas del punto
# constructor
def initialize a, b
setPoint a, b
end
# asigna a x,y las coordenadas del punto

public
def setPoint a, b
@x = a
@y = b
end
# convierte informacion a cadena

def to_s
return "[ #{@x}, #{@y} ]"
end
end
# Definicion de clase circulo

class Circle < Point # Hereda de Point
attr_reader :radius
@radius

- 250 -
# Constructor
def initialize r, a, b
super a, b # llamada a constructor de clase base
setRadius r
end
# Asigna radio del circulo

def setRadius r
@radius = ( r >= 0 ? r : 0 )
end
# Calculo area del circulo

def area
return 3.14159 * radius * radius
end
# Convierte informacion en cadena

def to_s
return "Centro = [ #{@x}, #{@y} ]; Radio = #{@radius}"
end
end
# código de Prueba de las clases Point y Circle
def prueba
p = Point.new 3.5, 5.3
c = Circle.new 2.7, 1.2, 8.9
puts "Punto p: " + p.to_s

puts "Circulo c: " + c.to_s
# Tratamiento del circulo como instancia de punto

pointRef = c; # asignar circulo c a pointRef no hace
diferencia porque los identificadores no tienen tipo
# en realidad Ruby lo reconoce dinámicamente como objeto
Circle sin importar el identificador
puts "Circulo c (via pointRef): " + pointRef.to_s

- 251 -
pointRef = c; # asigna circulo c a pointref. Se repite

la operacion por claridad
circleRef = pointRef # es asignación de referencias sin
importar el tipo
end
prueba
Redefinición de métodos
Ruby permite redefinir un método de la clase base en la clase derivada.

Cuando se hace referencia al nombre del método, se ejecuta la versión de la clase
en donde fue redefinida. Es posible sin embargo, utilizar el método de la clase
base por medio la palabra super. A diferencia de Java aquí solo es necesaria esta
palabra (y si se necesita la lista de argumentos) para llamar al método
correspondiente de la clase base desde la clase derivada.
Ejemplo:
#clase empleado
class Empleado
@firstName
@lastName
def initialize first, last

@firstName = String.new(first)
@lastName = String.new(last)
end
def print
puts @firstName.to_s + " " + @lastName.to_s
end
end

- 252 -
#clase TrabajadorporHora
class TrabajadorPorHora < Empleado
@wage
@hours
def initialize first, last, initHours, initWage

super first, last
@hours = initHours
@wage = initWage
end
def getPay
@wage * @hours
end
def print
puts "Metodo print de Trabajador por hora"
super # llama a función de clase base
puts " es un trabajador por hora con sueldo de" +" $"
+ getPay.to_s
end
end
#prueba de clases
e= Empleado.new "nombre", "apellido"
h= TrabajadorPorHora.new "Juanito", "Perez", 40.0, 7.50

e.print
h.print();

- 253 -
Módulos
Un módulo es definido con la sintaxis:
module <nombre-módulo>
<código>
end
De hecho, un módulo, aunque es similar a una clase no puede tener

imstancias ni subclases y añade un nuevo alcance para variables locales. Un
módulo que es definido con el nombre de otro previamente definido añadira sus
definiciones al módulo inicial. En el diseño de Ruby, la clase Module de module
es la superclase de la clase Class de class ! [13]
Cuando existe ambigüedad , es posible referirse a un método o identificador

dentro de un módulo usando el operador ::, por ejemplo:
nombre-módulo::método
También es posible referirse directamente a los elementos dentro de un

módulo sin necesidad de usar el nombre del módulo y el operador :: en cada
ocasión. Para esto podemos incluir (include) el módulo. Esta característica da
además lugar a los mixins que se verán posteriormente. Es importante notar que
include hace referencia a un módulo y no a un archivo. Si el módulo esta en un
diferente archivo, este debe ser solicitado mediante la instrucción require antes de
poder ser incluido [12].

- 254 -
Mixins
En lugar de interfaces, Ruby tiene mixins, que es es la capacidad de un

módulo de ser añadido a una clase o a otro módulo con la operación include [9].
De hecho, un mixin puede verse como una interfaz pero con sus métodos
implementados. Además, es posible heredar características de uno o mas mixins
(módulos) siendo esto herencia múltiple. El concepto de mixin apareció en el
lenguaje Flavors. El nombre fue inspirado en una máquina de helados que ofrecia
en sabores básicos mezclados con ingredientes extras, estos helados eran
llamados “Mix-In”.35
Es importante señalar que en la definición del módulo pueden incluirse
atributos y restricciones de acceso, mismos que serán pasados a la clase que
incluye dicho módulo. Una vez definido el módulo, éste puede ser añadido a una
clase de la siguiente forma:
class unaClase
include <nombre-módulo>
...
end
Ejemplo:
#modulo
module Stack
def push(item) end
def pop; end
end
#clase incluye modulo

class StackImpl
include Stack
35
“For a real ice cream treat, try _Steve's Ice Cream_ (191 Elm Street, Sommerville). Steve's homemade ice
cream is perhaps the best in town. Cones are $.35 and $.55, and for $.10 each you can choose "mix-ins,"
consisting of M&M's, Heath bars, and many others. If you want fruit mixed in it costs $.10 more. Sundaes
are $.75 and $1.25, banana splits are $1.75, and egg creams are $.40. The portions at Steve's are large, and
so are the lines, so expect to do a little waiting. It's worth it.” [14] pág. 224
- 255 -
@stackArray
@tos
public
def initialize
@stackArray = []
@tos = -1
end
#implementa el método definido en el módulo

def push item
@stackArray[@tos+=1] = item
end
#implementa el método definido en el módulo

def pop
objRef = @stackArray[@tos]
@stackArray[@tos] = nil
@tos-=1
return objRef
end
def peek
return @stackArray[@tos]
end
end
# extendiendo un módulo puede ser hecho en el mismo módulo

# dinámicamente o en otro módulo. Pero en este caso las
queremos separadas
=begin
module Stack
def isEmpty
end
def isFull
end
end
=end
module SafeStack
def isEmpty

- 256 -
end
def isFull
end
end
# esta clase hereda la implementación de la pila StackImpl

# e implementa la nueva interfaz extendida SafeStack
class SafeStackImpl < StackImpl
include SafeStack
def initialize
super
end
# implementa los métodos de la interfaz

def isEmpty
return tos < 0
end
def isFull
tos >= stackArray.length
end
end
def stackUser
safeStackRef = SafeStackImpl.new
safeStackRef.push("Dolar");
safeStackRef.push "Peso"
puts safeStackRef.pop
puts safeStackRef.pop
puts safeStackRef.class
end
stackUser
Aunque la instrucción include nos puede recordar a la misma instrucción en

C/C++, en realidad es diferente. #imclude en C/C++ es ejecutada por el
preprocesador e indica que el archivo correspondiente debe ser insertado
momentos previos a la compilación.
- 257 -
Además, en Ruby, no se copia el código, sino que se hace una referencia de

la clase al módulo incluido. Múltiples clases pueden tener referencia al mismo
módulo y si este módulo es modificado, inclusive mientras el programa esta
ejecutándose, todas las clases se verán afectadas en su comportamiento [12].
Mucha de la fuerza del uso de mixins esta en la funcionalidad que añade a las
clases, pero en código bien diseñado este poder puede verse aún más si el código
en el mixin interactua con el código de las clases.

- 258 -
Asociaciones entre clases en C++
Una clase puede estar relacionada con otra clase, o en la práctica un objeto
con otro objeto.
En el modelado de objetos a la relación entre clases se le conoce como

asociación; mientras que a la relación entre objetos se le conoce como instancia
de una asociación.
Ejemplo:
Una clase Estudiante está relacionada con una clase Universidad.
Una relación es una conexión física o conceptual entre objetos. Las

relaciones36 se consideran de naturaleza bidireccional; es decir, ambos lados de la
asociación tienen acceso a clase del otro lado de la asociación. Sin embargo,
algunas veces únicamente es necesaria una relación en una dirección
(unidireccional).
Profesor Cubículo
Asociación
Comúnmente las asociaciones se representan en los lenguajes de

programación orientados a objetos como apuntadores. Donde un apuntador a una
clase B en una clase A indicaría la asociación que tiene A con B; aunque no así la
asociación de B con A.
36
El término de relación es usado muchas veces como sinónimo de asociación, debido a que el concepto
surge de las relaciones en bases de datos relacionales. Sin embargo el término más apropiado es el de
asociación, ya que existen en objetos otros tipos de relaciones, como la relación de agregación y la de
herencia.
- 259 -
Para una asociación bidireccional es necesario al menos un par de

apuntadores, uno en cada clase. Para una asociación unidireccional basta un solo
apuntador en la clase que mantiene la referencia.
Ejemplo: un programa que guarda una relación bidireccional entre clases A y B.
class A{
//lista de atributos
B *pB;
};
class B{
A *pA;
};
En el ejemplo anterior se presenta una relación bidireccional, por lo que

cada clase tiene su respectivo apuntador a la clase contraria de la relación.
Además, deben proporcionarse métodos de acceso a la clase relacionada por
medio del apuntador.
En el caso de las relaciones se asumirá que cada objeto puede seguir

existiendo de manera independiente, a menos que haya sido creado por el objeto
de la clase relacionada, en cuyo caso deberá ser eliminado por el destructor del
objeto que la creó. Es decir:
Si el objeto A crea al objeto B, es responsabilidad de A

eliminar a la instancia B antes de que A sea eliminada. En
caso contrario, si B es independiente de la instancia A, A
debería enviar un mensaje al objeto B para que asigne NULL al
apuntador de B o para que tome una medida pertinente, de
manera que no quede apuntando a una dirección inválida.
Es importante señalar que las medidas que se tomen pueden variar de

acuerdo a las necesidades de la aplicación, pero bajo ningún motivo se deben

- 260 -
dejar accesos a áreas de memoria no permitidas o dejar objetos "volando", sin que
nadie haga referencia a ellos.
Mencionamos a continuación estructuras clásicas que pueden ser vistas como

una relación:
1. Ejemplo de relación unidireccional: lista ligada.
2. Ejemplo de relación bidireccional: lista doblemente ligada.
Asociaciones reflexivas en C++
Es posible tener un tipo de asociación conocida como asociación reflexiva.
Si una clase mantiene una asociación consigo misma se dice que es una
asociación reflexiva.
Ejemplo: Persona puede tener relaciones entre si, si lo que nos interesa es
representar a las personas que guardan una relación entre sí, por ejemplo si son
parientes. Es decir, un objeto mantiene una relación con otro objeto de la misma
clase.
Persona
Asociación reflexiva
En terminos de implementación significa que la clase tiene una referencia a

si misma. De nuevo podemos poner de ejemplo a la clase Nodo en una lista
ligada.

- 261 -
Multiplicidad de una asociación en C++
La multiplicidad de una asociación especifica cuantas instancias de una

clase se pueden relacionar a una sola instancia de otra clase.
Se debe determinar la multiplicidad para cada clase en una asociación.
Tipos de asociaciones según su multiplicidad
"uno a uno": donde dos objetos se relacionan de forma exclusiva, uno con el
otro.
Ejemplo:
Uno: Un alumno tiene una boleta de calificaciones.
Uno: Una boleta de calificaciones pertenece a un alumno.
"uno a muchos": donde uno de los objetos puede estar relacionado con
muchos otros objetos.
Ejemplo:
Uno: un libro solo puede estar prestado a un alumno.
Muchos: Un usuario de la biblioteca puede tener muchos libros
prestados.
"muchos a muchos": donde cada objeto de cada clase puede estar relacionado
con muchos otros objetos.
Ejemplo:
Muchos: Un libro puede tener varios autores.
Muchos: Un autor puede tener varios libros.

- 262 -
Podemos apreciar en un diagrama las diversas multiplicidades:
Departamento
1 1
* *
Empleo * * Proyecto
La forma de implementar en C++ este tipo de relaciones puede variar, pero

la más común es por medio de apuntadores a objetos. Suponiendo que tenemos
relaciones bidireccionales:
"uno a uno". Un apuntador de cada lado de la relación, como se ha visto

anteriormente.
"uno a muchos". Un apuntador de un lado y un arreglo de apuntadores a

objetos definido dinámica o estáticamente.
class A{
...
B *pB;
};
class B{
A *p[5];
//ó
A **p;
}
Otra forma es manejar una clase que agrupe a pares de direcciones en un

objeto independiente de la clase. Por ejemplo una lista o tabla de referencias.

- 263 -
Persona
Compañía
Persona
Persona
Compañía
Persona
"muchos a muchos". Normalmente se utiliza un objeto u objetos

independientes que mantiene las relaciones entre los objetos, de manera similar
a la gráfica anterior.
Ejemplo:
Se muestra un código simplificado para manejo de asociaciones.
Clase Libro
#ifndef LIBRO_H_
#define LIBRO_H_
class Persona;
class Libro {
public:
char nombre[10];
Persona *pPersona;
Libro();
~Libro();
};
#endif /*LIBRO_H_*/
#include <iostream>
#include "Persona.h"
#include "Libro.h"

- 264 -
Libro::Libro(){
nombre[0]='\0';
pPersona=NULL;
}
Libro::~Libro(){
if(pPersona!=NULL)
for(int i=0; i<5; i++)
if (pPersona->pLibrosPres[i]==this)
pPersona->pLibrosPres[i]=NULL;
Clase Persona
#ifndef PERSONA_H_
#define PERSONA_H_
class Libro;
class Persona {
public:
Libro *pLibrosPres[5];
Persona();
~Persona();
};
#endif /*PERSONA_H_*/
#include <iostream>
#include "Libro.h"
#include "Persona.h"
Persona::Persona(){
int i;
for(i=0; i<5; i++)

pLibrosPres[i]=NULL;
}

- 265 -
Persona::~Persona(){
int i;
for(i=0; i<5; i++)
if(pLibrosPres[i]!=NULL)
pLibrosPres[i]->pPersona=NULL;
}
Asociaciones entre Clases en Java
Como en Java el manejo de objetos es mediante referencias, la

implementación de la asociación se simplifica en la medida que la sintaxis de
Java es más simple.
Ejemplo: un código que guarda una asociación bidireccional entre clases A y B.

class A{
B pB;
}
class B{
A pA;
}
En el ejemplo anterior se presenta una relación bidireccional, por lo que

cada clase tiene su respectiva referencia a la clase contraria de la relación.
Además, deben proporcionarse métodos de acceso a la clase relacionada por
medio de la referencia.
Una asociación unidireccional del ejemplo anterior sería más simple.

Veamos el código si se requiere únicamente una relación de A a B.

- 266 -
Ejemplo:
class A{
B pB;
}
class B{
}
Recordar: Si el objeto A crea al objeto B, es

responsabilidad de A eliminar a la instancia B antes de que A
sea eliminada. En caso contrario, si B es independiente de la
instancia A, A debería enviar un mensaje al objeto B para que
asigne null al apuntador de B o para que tome una medida
pertinente, de manera que no quede apuntando a una dirección
inválida.
En Java, ya que cuenta con un recolector de basura, la importancia radicaría

en asegurarnos de no mantener enlaces a objetos que ya no son necesarios.
Asociación reflexiva en Java
La asociación reflexiva es un concepto que no tiene diferencias con respecto

a C++.
Multiplicidad de una asociación en Java
La forma de implementar en Java este tipo de relaciones puede variar, pero

la más común es por medio de referencias a objetos. Suponiendo que tenemos
relaciones bidireccionales:
"uno a uno". Una referencia de cada lado de la relación, como se ha visto

anteriormente.

- 267 -
"uno a muchos". Una referencia de un lado y un arreglo de referencias a

objetos del otro lado.
class A{
...
B pB;
}
class B{
A p[];
}
Al igual que en C++, es posible manejar una clase independiente que agrupe
a pares de direcciones en un objeto independiente de la clase37. Por ejemplo, en
una estructura de lista.
"muchos a muchos". Normalmente se utiliza un objeto u objetos

independientes que mantiene las relaciones entre los objetos, de manera similar
a la solución descrita en el punto anterior.
Ejemplo:
Se muestra un código simplificado para manejo de asociaciones.
//clase Libro
class Libro {
private String nombreLibro;
public Alumno pAlumno;
public Libro(){
//al momento de crearse la instancia, no existe
// relación con ningún Alumno
pAlumno=null;
}
protected void finalize(){
37
Ver figura en tema correspondiente de C++
- 268 -
//si es diferente de null, el libro está asignado a

algún Alumno
if(pAlumno!=null)
//busca la referencia de Alumno a Libro para
ponerla en null
if (pAlumno.pLibrosPres[i]==this)
pAlumno.pLibrosPres[i]=null;
}
}
//clase Alumno
class Alumno {
public Libro pLibrosPres[];
public Alumno(){
int i;
//se asume una multiplicidad de 5
pLibrosPres = new Libro[5]
for(i=0; i<5; i++)
pLibrosPres[i]=null;
}
protected void finalize(){
//pone en null todas las asociaciones de los Libros

// a su instancia de Alumno que se elimina
if(pLibrosPres[i]!=null)
pLibrosPres[i].pAlumno=null;
}
}
Este es un ejemplo incompleto de cómo se soluciona el manejo de

asociaciones entre clases, ya que además se deben de agregar métodos para
establecer y eliminar la asociación, en ambas clases si es una asociación
bidireccional, o en una clase únicamente si se trata de una asociación
unidireccional. Esos deben de ser los únicos métodos que tengan el control sobre
los atributos que mantienen la asociación y no deberían ser manejados
directamente, por lo que no deben ser públicos como aquí se presentaron.
- 269 -
Finalmente, es evidente que el control de las asociaciones no se encuentra

actualmente apoyado por los lenguajes de programación, a pesar de ser una
necesidad natural en el modelado orientado a objetos, por lo que toda la
responsabilidad recae sobre el programador.
Una definición más completa - sin código - de la clase Libro se aprecia a

continuación:
class Libro {
private String nombreLibro;
private String clave;
public Alumno pAlumno;
public Libro(){ }
public Libro( Alumno pAlumno){ }
public String getNombreLibro(){ }
public void setNombreLibro(String n){ }
public String getClave(){ }
public void setClave(String cve){ }
public boolean setAsociacion(Alumno pAlumno){ }
public boolean unsetAsociacion(){ }
public Alumno getAlumno(){ }
protected finalize {}
}
Este sería un estilo más apropiado para el desarrollo de asociaciones, aunque

existen otros más elaborados.

- 270 -
Asociaciones entre Clases en Ruby
El manejo de asociaciones en Ruby puede hacerse de forma similar a como

se mencionó en Java. De hecho es todavía más simple la definición debido a que
no es necesaria la declaración de tipos.
Ejemplo: un código que guarda una asociación bidireccional entre clases A y B.

class A
#lista de atributos
@pB
end
class B
#lista de atributos
@pA
end
Veamos el código si se requiere únicamente una relación de A a B.
Ejemplo:
class A
#lista de atributos
@pB
end
class B
#lista de atributos
end
Asociación reflexiva en Ruby
La asociación reflexiva es un concepto que no tiene diferencias con respecto

a C++ y Java.

- 271 -
Multiplicidad de una asociación en Ruby
La forma de implementar en Ruby este tipo de relaciones puede variar, pero

la más común es por medio de referencias a objetos, de forma similar a la usada
en Java.

- 272 -
Objetos compuestos en C++
Algunas veces una clase no puede modelar adecuadamente una entidad

basándose únicamente en tipos de datos simples. Los LPOO permiten a una clase
contener objetos. Un objeto forma parte directamente de la clase en la que se
encuentra declarado.
El objeto compuesto es una especie de relación, pero con una asociación

más fuerte con los objetos relacionados. A la noción de objeto compuesto se le
conoce también como objeto complejo o agregado.
Rumbaugh define a la agregación como "una forma fuerte de asociación,

en la cual el objeto agregado está formado por componentes. Los componentes
forman parte del agregado. El agregado, es un objeto extendido que se trata como
una unidad en muchas operaciones, aun cuando conste físicamente de varios
objetos menores." [15]
Ejemplo: Un automóvil se puede considerar ensamblado o agregado, donde

el motor y la carrocería serian sus componentes.
El concepto de agregación puede ser relativo a la conceptualización que se

tenga de los objetos que se quieran modelar.
Dicho concepto implica obviamente cierta dependencia entre los objetos, por
lo que hay que tener en cuenta que pasa con los objetos que son parte del objeto
compuesto cuando éste último se destruye. En general tenemos dos opciones:
1. Cuando el objeto agregado se destruye, los objetos que lo componen no tienen

necesariamente que ser destruidos.
2. Cuando el agregado es destruido también sus componentes se destruyen.

- 273 -
Por el momento vamos a considerar la segunda opción, por ser más fácil de
implementar y porque es la acción natural de los objetos que se encuentran
embebidos como un atributo más en una clase.
Ejemplo:
class Nombre {
private:
char paterno[20],
materno[20],
nom[15];
public:
set(char *, char*, char *);
...
};
class Persona {
private:
int edad;
Nombre nombrePersona;
...
};
Al crear un objeto compuesto, cada uno de sus componentes es creado con

sus respectivos constructores. Para inicializar esos objetos componentes tenemos
dos opciones:
1. En el constructor del objeto compuesto llamar a los métodos set

correspondientes a la modificación de los atributos de los objetos
componentes.
2. Pasar en el constructor del objeto compuesto los argumentos a los

constructores de los objetos componentes.

- 274 -
Sintaxis:
<clase>::<constructor>(<lista de argumentos>) : <objeto

componente 1>(<lista de argumentos sin el tipo>),...
donde la lista de argumentos del objeto compuesto debe incluir a los argumentos
de los objetos componentes, para que puedan ser pasados en la creación del
objeto.
Ejemplo:
#include <iostream>
#include <string.h>
class Nombre {
char *nombre,
*paterno,
*materno;
public:
Nombre(char *n, char *p, char*m){
nombre=new char[strlen(n)+1];
paterno=new char[strlen(p)+1];
materno=new char[strlen(m)+1];
strcpy(nombre, n);
strcpy(paterno, p);
strcpy(materno, m);
}
~Nombre(){
cout<<"destructor de Nombre: "<<nombre<<endl;
delete []nombre;
delete []paterno;
delete []materno;
}
};

- 275 -
class Persona{
Nombre miNombre;
int edad;
public:
Persona(char *n, char *p, char*m): miNombre(n, p, m){
edad=0;
}
};
int main() {
Persona *per1;
per1= new Persona("uno", "dos", "tres");
Persona per2("Bob", "the", "builder");
delete per1;
return 0;
}
Un objeto que es parte de otro objeto, puede a su vez ser un objeto

compuesto. De esta forma podemos tener múltiples niveles. Un objeto puede ser
un agregado recursivo, es decir, tener un objeto de su misma clase.
Ejemplo: Directorio de archivos.
Sin embargo, la forma en que estamos implementando la agregación no

permite la agregación recursiva.

- 276 -
UMLGEC ++
El proyecto de desarrollo de esta herramienta CASE (UMLGEC ++)[16, 17]

soporta la notación UML38 para diagramas de clase y generación de código en
C++, con una interfaz lo mas completa y sencilla posible. Siendo útil para
entender gráficamente conceptos básicos de objetos y su correspondiente
implementación en código. Los elementos de este software son:
• Depósito de datos
• Módulo para Creación de Diagramas y Modelado
• Generador de código
• Analizador de sintaxis
38
Información básica sobre UML puede ser vista en [18].
- 277 -
De la generación de código se puede decir:
• A partir del diagrama se genera la estructura de las clases.

• Se crean automáticamente: el constructor, el constructor de copia, el operador
de asignación, las operaciones de igualdad y el destructor.
• Todos los atributos y asociaciones son establecidos como privados
independientemente de la visibilidad establecida por el usuario, pero el acceso
a ellos está permitido mediante operaciones get y set generadas
automáticamente para cada atributo o asociación, las cuáles adquieren la
visibilidad correspondiente al atributo o asociación al que hacen referencia.
• Se definen los cuerpos de las operaciones get y set, como funciones inline.

- 278 -
Objetos compuestos en Java
En Java, puede no existir mucha diferencia entre la implementación de la

asociación y la agregación, debido a que en Java los objetos siempre son
manejados por referencias, pero el concepto se debe tener en cuenta para su
manejo, además de ser relevante a nivel de diseño de software.
Recordemos que en general hay dos opciones para el manejo de la

agregación:
1. Cuando el objeto agregado se destruye, los objetos que lo componen no

tienen necesariamente que ser destruidos.
Al igual que en C++, vamos a considerar la segunda opción, por ser más
fácil de implementar y es la acción natural de los objetos que se encuentran
embebidos como un atributo más una clase.
Ejemplo:
class Nombre {
private String paterno;
private String materno;
private String nom;
public set(String pat, String mat, String n) {

...
}
...
}
class Persona {
private int edad;
private Nombre nombrePersona;
...

- 279 -
A diferencia de lo que sucede en C++, los atributos compuestos no tienen

memoria asignada, es decir, los objetos compuestos no han sido realmente
creados en el momento en que se crea el objeto componente. Es responsabilidad
del constructor del objeto componente inicializar los objetos miembros o
compuestos, si es que así se requiere.
Para inicializar esos objetos componentes tenemos dos opciones:
1. En el constructor del objeto compuesto llamar a los métodos set

correspondientes a la modificación de los atributos de los objetos
componentes, esto después claro está de asignarle la memoria a los objetos
componentes.
2. Llamar a algún constructor especializado del objeto componente en el

momento de crearlo.
Ejemplo:
//Programa Persona
class Nombre {
private String nombre,
paterno,
materno;
public Nombre(String n, String p, String m){
nombre= new String(n);
paterno= new String(p);
materno= new String(m);
}
}
public class Persona{

private Nombre miNombre;
private int edad;
public Persona(String n, String p, String m) {
miNombre= new Nombre(n, p, m);

- 280 -
edad=0;
}

Persona per1;
per1= new Persona("uno", "dos", "tres");
Persona per2= new Persona("mi nombre", "mi apellido",
"otro apellido");
}
}
La agregación nos dice también que un objeto que es parte de otro objeto,
puede a su vez ser un objeto compuesto. [19]
De esta forma podemos tener múltiples niveles. De hecho esto se ve en el

código anterior, si consideramos que en realidad String es una clase y no un tipo
de dato simple. Así, se van ensamblando clases para formar una clase más grande
con una mayor funcionalidad, del mismo modo que el ensamble de objetos del
mundo real.
Pero también es posible que un objeto sea un agregado recursivo, es decir,

tener como parte de su componente un objeto de su misma clase. Considerar por
ejemplo un directorio de archivos, donde cada directorio puede contener, además
de archivos, a otros directorios39.
Otro ejemplo en Java:

// Clase MyDate
public class MyDate {
private int month; // 1-12
private int day; // 1-31 dependiendo del mes
39
Lo importante aquí es considerar en que solo existe la posibilidad de contener un objeto de si mismo. Si
esto fuera una condición obligatoria y no opcional, estaríamos definiendo un objeto infinito. Este problema
se ve reflejado en lenguajes como C++, donde la forma más simple de implementar la agregación es
definiendo un objeto al cual se le asigna espacio en tiempo de compilación, generando entonces el problema
de que cada objeto debe reservar memoria para sus componentes, por lo que el compilador no permite que de
esta manera se autocontenga. En Java esto no generaría problema porque implícitamente todos los atributos
que no son datos simples requieren de una asignación de memoria dinámica.
- 281 -
private int year; // cualquier año
public MyDate( int mn, int dy, int yr ) {

if ( mn > 0 && mn <= 12 )
month = mn;
else {
month = 1;
System.out.println( "Mes " + mn +
" invalido. Se asigno el mes 1." );
}
year = yr;
day = checkDay( dy ); // validar el dia
System.out.println("Constructor de objeto MyDate para

fecha " + toString() );
}
// verifica que el dia sea correcto de acuerdo al mes

private int checkDay( int testDay ) {
int daysPerMonth[] = { 0, 31, 28, 31, 30,
31, 30, 31, 31, 30,
31, 30, 31 };
if ( testDay > 0 && testDay <= daysPerMonth[ month ] )

return testDay;
if ( month == 2 && // Febrero, si el año es bisiesto

testDay == 29 &&
( year % 400 == 0 ||
( year % 4 == 0 && year % 100 != 0 ) ) )
return testDay;
System.out.println( "Dia " + testDay +

" invalido. Se asigno el dia 1." );
return 1; // deja al objeto en un estado consistente

}
public String toString()

- 282 -
{ return month + "/" + day + "/" + year; }

}
// Clase Empleado
public class Employee {
private String firstName;

private String lastName;
private MyDate birthDate;
private MyDate hireDate;
public Employee( String fName, String lName,

int bMonth, int bDay, int bYear,
int hMonth, int hDay, int hYear) {
firstName = fName;
lastName = lName;
birthDate = new MyDate( bMonth, bDay, bYear );
hireDate = new MyDate( hMonth, hDay, hYear );
}

return lastName + ", " + firstName +
" Contratado: " + hireDate.toString() +
" Fecha nacimiento: " + birthDate.toString();
}
}
// clase EmployeeTest
public class EmployeeTest{
private Employee e;
public EmployeeTest() {
e = new Employee( "Juanito", "Sanchez", 7, 24, 49,
3, 12, 88 );
}

EmployeeTest et= new EmployeeTest();
System.out.println( et.e.toString()); }
}

- 283 -
Objetos compuestos en Ruby
En Ruby, como en Java, puede no existir mucha diferencia entre la

implementación de la asociación y la agregación, debido a que en Ruby los
objetos siempre son manejados por referencias, pero el concepto se debe tener en
cuenta para su manejo, además de ser relevante a nivel de diseño de software.
Recordemos que en general hay dos opciones para el manejo de la

agregación:
1. Cuando el objeto agregado se destruye, los objetos que lo componen no

tienen necesariamente que ser destruidos.
Al igual que en C++ y Java, vamos a considerar la segunda opción, por ser
más fácil de implementar y es la acción natural de los objetos que se encuentran
embebidos como un atributo más una clase.
Ejemplo:
class Nombre
@paterno
@materno
@nom
def set (paterno, materno, nombre)

...
end
...
end
class Persona
@edad
@nombrePersona
...

- 284 -
end
Como ya se sabe, los identificadores para los atributos no tienen un tipo

asociado, sino que son asignados a un objeto en tiempo de ejecución. Es
responsabilidad del inicializador del objeto componente inicializar los objetos
miembros o compuestos, si es que así se requiere.
Ejemplo:
#Programa Persona
class Nombre
@nombre
@paterno
@materno
def initialize(nombre, paterno, materno)
@nombre= String.new nombre
@paterno= String.new paterno
@materno= String.new materno
end
end
class Persona
@miNombre
@edad
def initialize(n, p, m)
@miNombre = Nombre.new(n, p, m)
@edad =0
end
end
#código de prueba
per1= Persona.new("uno", "dos", "tres")
per2= Persona.new("mi nombre", "mi apellido", "otro apellido")
Otro ejemplo en Ruby:

# Clase MyDate
class MyDate
- 285 -
@month # 1-12
@day # 1-31 dependiendo del mes
@yea; # cualquier año
def initialize (mn, dy, yr)

if ( mn > 0 && mn <= 12 )
@month = mn;
else
@month = 1;
puts "Mes #{mn} invalido. Se asigno el mes 1."
end
@year = yr;
@day = checkDay( dy ); # validar el dia
puts "Inicializador de objeto MyDate para fecha " + to_s

end
# verifica que el dia sea correcto de acuerdo al mes

def checkDay (testDay)
daysPerMonth = [0, 31, 28, 31, 30,
31, 30, 31, 31, 30,
31, 30, 31]
if ( testDay > 0 && testDay <= daysPerMonth[@month] )

return testDay
end
if ( @month == 2 && # Febrero, si el año es bisiesto

testDay == 29 &&
( @year % 400 == 0 ||
( @year % 4 == 0 && @year % 100 != 0 ) ) )
return testDay
end
puts "Dia #{testDay.to_s} invalido. Se asigno el dia 1."
return 1 # deja al objeto en un estado consistente

end

- 286 -
def to_s
return @month.to_s + "/" + @day.to_s + "/" + @year.to_s
end
end
# Clase Empleado
class Employee
@firstName
@lastName
@birthDate
@hireDate
def initialize (fName, lName, bMonth, bDay, bYear,

hMonth, hDay, hYear)
@firstName = fName
@lastName = lName
@birthDate = MyDate.new( bMonth, bDay, bYear )
@hireDate = MyDate.new( hMonth, hDay, hYear )
end
def to_s
return @lastName + ", " + @firstName +
" Contratado: " + @hireDate.to_s +
" Fecha nacimiento: " + @birthDate.to_s
end
end
# clase EmployeeTest
class EmployeeTest
attr_reader :e
@e
def initialize
@e = Employee.new( "Juanito", "Sanchez", 7, 24, 49,
3, 12, 88 )
end
end

- 287 -
# codigo de prueba
et= EmployeeTest.new
puts et.e.to_s

- 288 -
Funciones virtuales y polimorfismo en C++
“La capacidad de polimorfismo permite crear programas con mayores

posibilidad de expansiones futuras, aún para procesar en cierta forma objetos de
clases que no han sido creadas o están en desarrollo.”[20]
El polimorfismo es implementado en C++ a través de clases derivadas y

funciones virtuales.
Una función virtual es un método miembro declarado como virtual en una

clase base y siendo este método redefinido en una o más clases derivadas.
Las funciones virtuales son muy especiales, debido a que cuando una
función es accesada por un apuntador a una clase base, y éste mantiene una
referencia a un objeto de una clase derivada, el programa determina en tiempo de
ejecución a que función llamar, de acuerdo al tipo de objeto al que se apunta.
Esto se conoce como ligadura tardía40 y el compilador de C++ incluye en el
código máquina el manejo de ese tipo de asociación de métodos.
La utilidad se da cuando se tiene un método en una clase base, y este es

declarado virtual. De esta forma, cada clase derivada puede tener su propia
implementación del método si es que así lo requiere la clase; y si un apuntador a
clase base hace referencia a cualquiera de los objetos de clases derivadas, se
determina dinámicamente cual de todos los métodos debe ejecutar.
La sintaxis en C++ implica declarar al método de la clase base con la

palabra reservada virtual, redefiniendo ese método en cada una de las clases
derivadas.
Al declarar un método como virtual, este método se conserva asi a través de

toda la jerarquía de herencia, del punto en que se declaro hacia abajo. Aunque de
40
Término opuesto a ligadura temprana o ligadura estática, la cual asocia los métodos en tiempo de
compilación.
- 289 -
este modo no es necesario volver a usar la palabra virtual en ninguno de los

métodos inferiores del mismo nombre, es posible declararlo de forma explícita
para que el programa sea más claro.
Es importante señalar que las funciones virtuales que sean redefinidas en

clases derivadas, deben tener además de la misma firma que la función virtual
base, el mismo tipo de retorno.
Sintaxis:
class base {
virtual <tipo> <método> (<parámetros);
};
Ejemplo:
//ejemplo funciones virtuales

#include <iostream>
class base {
public:
virtual void quien(){
cout<<"base\n";
}
};
class primera: public base {

public:
void quien(){
cout<<"primera\n";
}
};
class segunda: public base {

public:
void quien(){

- 290 -
cout<<"segunda\n";
}
};
class tercera: public base {

};
class cuarta: public base {

public:
//No se vale con un tipo de dato diferente
/*int quien(){
cout<<"cuarta\n";
return 1;
}*/
};
int main() {
base objBase, *pBase;
primera obj1;
segunda obj2;
tercera obj3;
cuarta obj4;
pBase=&objBase;
pBase->quien();
pBase=&obj1;
pBase->quien();
pBase=&obj2;
pBase->quien();
pBase=&obj3;
pBase->quien();
pBase=&obj4;
pBase->quien();
return 0;
}

- 291 -
Hay que hacer notar que las funciones virtuales pueden seguirse usando sin
apuntadores, mediante un objeto de la clase. De esta forma, el método a ejecutar
se determina de manera estática; es decir, en tiempo de compilación (ligadura
estática). Obviamente el método a ejecutar es aquel definido en la clase del objeto
o el heredado de su clase base, si la clase derivada no lo redefinió.
Si se declara en una clase derivada un método con otro tipo de dato como
retorno, el compilador manda un error, ya que esto no es permitido.
Si se declara un método con el mismo nombre pero diferentes parámetros, la

función virtual queda desactivada de ese punto hacia abajo en la jerarquía de
herencia.
Clase abstracta y clase concreta en C++
Existen clases que son útiles para representar una estructura en particular,
pero que no van a tener la necesidad de generar objetos directamente a partir de
esa clase, estas se conocen como clases abtractas, o de manera más apropiada
como clases base abstractas, puesto que sirven para definir una estructura
jerarquica.
La clase base abstracta entonces, tiene como objetivo proporcionar una clase
base que ayude al modelado de la jerarquía de herencia, aunque esta sea muy
general y no sea práctico tener instancias de esa clase.
Por lo tanto, de una clase abstracta no se pueden tener objetos, mientras que
en clases a partir de las cuales se puedan instanciar objetos se conocen como
clases concretas.
En C++, una clase se hace abstracta al declarar al menos uno de los

métodos virtuales como puro. Un método o función virtual pura es aquel que en
su declaración tiene el inicializador de =0 .

- 292 -
virtual <tipo> <nombre>(<parámetros>) =0; //virtual pura
Es importante tener en cuenta que una clase sigue siendo abstracta hasta que
no se implemente la función virtual pura, en una de las clases derivadas. Si no se
hace la implementación, la función se hereda como virtual pura y por lo tanto la
clase sigue siendo considerada como abstracta.
Aunque no se pueden tener objetos de clases abstractas, si se pueden tener

apuntadores a objetos de esas clases, permitiendo una manipulación de objetos de
las clases derivadas mediante los apuntadores a la clase abstracta.
Polimorfismo
El polimorfismo se define como la capacidad de objetos de clases diferentes,

relacionados mediante herencia, a responder de forma distinta a una misma
llamada de un método. [11]
En C++, el polimorfismo se implementa con las funciones virtuales. Al

hacer una solicitud de un método, a través de un apuntador a clase base para usar
un método virtual, C++ determina el método que corresponda al objeto de la clase
a la que pertenece, y no el método de la clase base.
Tener en cuenta que no es lo mismo que simplemente redefinir un método

de clase base en una clase derivada, pues como se vio anteriormente, si se tiene a
un apuntador de clase base y a través de el se hace la llamada a un método, se
ejecuta el método de la clase base independientemente del objeto referenciado por
el apuntador. Este no es un comportamiento polimórfico.

- 293 -
Destructores virtuales
Cuando se aplica la instrucción delete a un apuntador de clase base, será

ejecutado el destructor de la clase base sobre el objeto, independientemente de la
clase a la que pertenezca. La solución es declarar al destructor de la clase base
como virtual. De esta forma al borrar a un objeto se ejecutará el destructor de la
clase a la que pertenezca el objeto referenciado, a pesar de que los destructores no
tengan el mismo nombre.
Un constructor no puede ser declarado como virtual.
Ejemplos de funciones virtuales y polimorfismo:
Programa de cálculo de salario.

// EMPLEADO.H
// Abstract base class Employee
#ifndef EMPLEADO_H_
#define EMPLEADO_H_
class Employee {
public:
Employee(const char *, const char *);
~Employee();
const char *getFirstName() const;
const char *getLastName() const;
virtual float earnings() const = 0; // virtual pura

virtual void print() const = 0; // virtual pura
private:
char *firstName;
char *lastName;
};
#endif /*EMPLEADO_H_*/

- 294 -
// EMPLEADO.CPP
#include <iostream>
#include <string>
#include <assert.h>
#include "empleado.h"
Employee::Employee(const char *first, const char *last)

{
firstName = new char[ strlen(first) + 1 ];
assert(firstName != 0);
strcpy(firstName, first);
lastName = new char[ strlen(last) + 1 ];

assert(lastName != 0);
strcpy(lastName, last);
}
Employee::~Employee()
{
delete [] firstName;
delete [] lastName;
}
const char *Employee::getFirstName() const

{
return firstName;
}
const char *Employee::getLastName() const

{
return lastName;
}

- 295 -
// JEFE.H
// Clase drivada de empleado
#ifndef JEFE_H_
#define JEFE_H_
class Boss : public Employee {

public:
Boss(const char *, const char *, float = 0.0);
void setWeeklySalary(float);
virtual float earnings() const;
virtual void print() const;
private:
float weeklySalary;
};
#endif /*JEFE_H_*/
// JEFE.CPP
#include <iostream>
#include "jefe.h"
Boss::Boss(const char *first, const char *last, float s)
: Employee(first, last)
{ weeklySalary = s > 0 ? s : 0; }
void Boss::setWeeklySalary(float s)
{ weeklySalary = s > 0 ? s : 0; }
float Boss::earnings() const { return weeklySalary; }
void Boss::print() const

{
cout << "\n Jefe: " << getFirstName()
<< ' ' << getLastName();
}

- 296 -
// COMIS.H
// Trabajador por comisión derivado de Empleado
#ifndef COMIS_H_
#define COMIS_H_
class CommissionWorker : public Employee {

public:
CommissionWorker(const char *, const char *,
float = 0.0, float = 0.0, int = 0);
void setSalary(float);
void setCommission(float);
void setQuantity(int);
private:
float salary; // salario base por semana
float commission; // comisión por cada venta
int quantity; // cantidad de elementos vendidos por
semana
};
#endif /*COMIS_H_*/
// COMIS.CPP
#include <iostream>
#include "comis.h"
CommissionWorker::CommissionWorker(const char *first,

const char *last, float s, float c, int q)
{
salary = s > 0 ? s : 0;
commission = c > 0 ? c : 0;
quantity = q > 0 ? q : 0;
}

- 297 -
void CommissionWorker::setSalary(float s)
{ salary = s > 0 ? s : 0; }
void CommissionWorker::setCommission(float c)
{ commission = c > 0 ? c : 0; }
void CommissionWorker::setQuantity(int q)
{ quantity = q > 0 ? q : 0; }
float CommissionWorker::earnings() const

{ return salary + commission * quantity; }
void CommissionWorker::print() const

{
cout << "\nTrabajador por comision: " << getFirstName()
}
// PIEZA.H
// Trabajador por pieza derivado de Empleado
#ifndef PIEZA_H_
#define PIEZA_H_
class PieceWorker : public Employee {

public:
PieceWorker(const char *, const char *,
float = 0.0, int = 0);
void setWage(float);
void setQuantity(int);
private:
float wagePerPiece; // pago por cada pieza
int quantity; // piezas por semana
};
#endif /*PIEZA_H_*/

- 298 -
// PIEZA.CPP
#include <iostream>
#include "pieza.h"
// Constructor for class PieceWorker

PieceWorker::PieceWorker(const char *first,
const char *last, float w, int q)
{
wagePerPiece = w > 0 ? w : 0;
quantity = q > 0 ? q : 0;
}
void PieceWorker::setWage(float w)
{ wagePerPiece = w > 0 ? w : 0; }
void PieceWorker::setQuantity(int q)
{ quantity = q > 0 ? q : 0; }
float PieceWorker::earnings() const

{ return quantity * wagePerPiece; }
void PieceWorker::print() const {

cout << "\n Tabajador por pieza: " << getFirstName()
}
// HORA.H
// Trabajador por hora derivado de Empleado
#ifndef HORA_H_
#define HORA_H_
class HourlyWorker : public Employee {

public:
HourlyWorker(const char *, const char *,

- 299 -
float = 0.0, float = 0.0);

void setWage(float);
void setHours(float);
private:
float wage; // salario por hora
float hours; // horas trabajadas en la semana
};
#endif /*HORA_H_*/
// HORA.CPP
#include <iostream>
#include "hora.h"
HourlyWorker::HourlyWorker(const char *first, const char

*last,
float w, float h)
{
wage = w > 0 ? w : 0;
hours = h >= 0 && h < 168 ? h : 0;
}
void HourlyWorker::setWage(float w) { wage = w > 0 ? w : 0; }
void HourlyWorker::setHours(float h)
{ hours = h >= 0 && h < 168 ? h : 0; }
float HourlyWorker::earnings() const { return wage * hours; }
void HourlyWorker::print() const

{
cout << "\n Trabajador por hora: " << getFirstName()
}

- 300 -
// main.cpp
#include <iostream>
#include <iomanip>
#include "jefe.h"
#include "comis.h"
#include "pieza.h"
#include "hora.h"
int main(){
// formato de salida
cout << setiosflags(ios::showpoint) << setprecision(2);
Employee *ptr; // apuntador a clase base
Boss b("John", "Smith", 800.00);

ptr = &b; // apuntador de clase base apuntando a objeto de
clase derivada
ptr->print(); // ligado dinámico
cout << " ganado $" << ptr->earnings(); // ligado dinámico
b.print(); // ligado estático
cout << " ganado $" << b.earnings(); // ligado estático
CommissionWorker c("Sue", "Jones", 200.0, 3.0, 150);

ptr = &c;
ptr->print();
cout << " ganado $" << ptr->earnings();
c.print();
cout << " ganado $" << c.earnings();
PieceWorker p("Bob", "Lewis", 2.5, 200);

ptr = &p;
ptr->print();
p.print();
cout << " ganado $" << p.earnings();
HourlyWorker h("Karen", "Precio", 13.75, 40);

- 301 -
ptr = &h;
ptr->print();
h.print();
cout << " ganado $" << h.earnings();
cout << endl;

return 0;
}

- 302 -
Programa de figuras geométricas con una interfaz abstracta Shape (Forma)

// Figura.H
#ifndef figura_H
#define figura_H
class Shape {
public:
virtual float area() const { return 0.0; }
virtual float volume() const { return 0.0; }
virtual void printShapeName() const = 0; // virtual pura
};
#endif
// Punto.H
#ifndef PUNTO_H_
#define PUNTO_H_
#include <iostream>
#include "figura.h"
class Point : public Shape {

friend ostream &operator<<(ostream &, const Point &);
public:
Point(float = 0, float = 0);
void setPoint(float, float);
float getX() const { return x; }
float getY() const { return y; }
virtual void printShapeName() const { cout << "Punto: "; }
private:
float x, y;
};
#endif /*PUNTO_H_*/
// Punto.CPP
#include "punto.h"
Point::Point(float a, float b)
{
x = a;

- 303 -
y = b;
}
void Point::setPoint(float a, float b)

{
x = a;
y = b;
}
ostream &operator<<(ostream &output, const Point &p)

{
output << '[' << p.x << ", " << p.y << ']';
return output;
}
// Circulo.H
#ifndef CIRCULO_H_
#define CIRCULO_H_
#include "punto.h"
class Circle : public Point {

friend ostream &operator<<(ostream &, const Circle &);
public:
Circle(float r = 0.0, float x = 0.0, float y = 0.0);
void setRadius(float);
float getRadius() const;
virtual float area() const;
virtual void printShapeName() const { cout << "Circulo: ";
}
private:
float radius;
};
#endif /*CIRCULO_H_*/
// Circulo.CPP
#include <iostream>
#include "circulo.h"

- 304 -

: Point(a, b)
{ radius = r > 0 ? r : 0; }
void Circle::setRadius(float r) { radius = r > 0 ? r : 0; }
float Circle::getRadius() const { return radius; }
float Circle::area() const { return 3.14159 * radius * radius;

}
ostream &operator<<(ostream &output, const Circle &c)

{
output << '[' << c.getX() << ", " << c.getY()
<< "]; Radio=" << setiosflags(ios::showpoint)
<< setprecision(2) << c.radius;
return output;
}
// Cilindro.H
#ifndef CILINDRO_H_
#define CILINDRO_H_
class Cylinder : public Circle {

friend ostream &operator<<(ostream &, const Cylinder &);
public:
Cylinder(float h = 0.0, float r = 0.0,
float x = 0.0, float y = 0.0);
void setHeight(float);
virtual float area() const;
virtual float volume() const;
virtual void printShapeName() const { cout << "Cilindro: ";
}
private:

- 305 -
float height; // altura del cilindro

};
#endif /*CILINDRO_H_*/
// Cilindro.CPP
#include <iostream>
#include "cilindro.h"
Cylinder::Cylinder(float h, float r, float x, float y)

: Circle(r, x, y)
{ height = h > 0 ? h : 0; }
void Cylinder::setHeight(float h)
{ height = h > 0 ? h : 0; }
float Cylinder::area() const

{
return 2 * Circle::area() +
2 * 3.14159 * Circle::getRadius() * height;
}
float Cylinder::volume() const

{
float r = Circle::getRadius();
return 3.14159 * r * r * height;
}
ostream &operator<<(ostream &output, const Cylinder& c)

{
output << '[' << c.getX() << ", " << c.getY()
<< "]; Radio=" << setiosflags(ios::showpoint)
<< setprecision(2) << c.getRadius()
<< "; Altura=" << c.height;
return output;
}

- 306 -
// main.CPP
#include <iostream>
#include "figura.h"
#include "punto.h"
#include "cilindro.h"
int main(){
Point point(7, 11);
Circle circle(3.5, 22, 8);
Cylinder cylinder(10, 3.3, 10, 10);
point.printShapeName(); // ligado estático

cout << point << endl;
circle.printShapeName();
cout << circle << endl;
cylinder.printShapeName();
cout << cylinder << "\n\n";
cout << setiosflags(ios::showpoint) << setprecision(2);
Shape *ptr; // apuntador de clase base
// apuntador de clase base referenciando objeto de clase

derivada
ptr = &point;
ptr->printShapeName(); // ligado dinámico
cout << "x = " << point.getX() << "; y = " << point.getY()
<< "\nArea = " << ptr->area()
<< "\nVolumen = " << ptr->volume() << "\n\n";
ptr = &circle;
ptr->printShapeName();
cout << "x = " << circle.getX() << "; y =" << circle.getY()
<< "\nVolumen = " << ptr->volume() << "\n\n";

- 307 -
ptr = &cylinder;
ptr->printShapeName(); // dynamic binding
cout << "x = " << cylinder.getX() << "; y = " <<
cylinder.getY()
<< "\nVolumen = " << ptr->volume() << endl;
return 0;
}

- 308 -
Clases Abstractas y Polimorfismo en Java
El polimorfismo es implementado en Java a través de clases derivadas y

clases abstractas.
Recordar: El polimorfismo se define como la capacidad de objetos de clases

diferentes, relacionados mediante herencia, a responder de forma distinta a una
misma llamada de un método.
Al hacer una solicitud de un método, a través de una variable de referencia a

clase base para usar un método, Java determina el método que corresponda al
objeto de la clase a la que pertenece, y no el método de la clase base.
Los métodos en Java - a diferencia de C++ - tienen este comportamiento por

default, debido a que cuando un método es accesado por una referencia a una
clase base, y esta mantiene una referencia a un objeto de una clase derivada, el
programa determina en tiempo de ejecución a que método llamar, de acuerdo al
tipo de objeto al que se apunta.
Esto como ya se ha visto, se conoce como ligadura tardía y permite otro

nivel de reutilización de código, resaltado por la simplificación con respecto a
C++ de no tener que declarar al método como virtual.
Ejemplo:
//ejemplo Prueba
class base {
public void quien(){
System.out.println("base");
}
}
class primera extends base {

System.out.println("primera");

- 309 -
}
}
class segunda extends base {

System.out.println("segunda");
}
}
class tercera extends base {
class cuarta extends base {

/*public int quien(){ No se vale con un tipo de dato
diferente
System.out.println("cuarta");
return 1;
}*/
}
public class Prueba {

base objBase= new base(), pBase;
primera obj1= new primera();
segunda obj2= new segunda();
tercera obj3= new tercera();
cuarta obj4= new cuarta();
pBase=objBase;
pBase.quien();
pBase=obj1;
pBase.quien();
pBase=obj2;
pBase.quien();
pBase=obj3;
pBase.quien();

- 310 -
pBase=obj4;
pBase.quien();
}
}
Como se aprecia en el ejemplo anterior, en caso de que el método no sea

redefinido, se ejecuta el método de la clase base.
Es importante señalar que – al igual que en C++- los métodos que sean
redefinidos en clases derivadas, deben tener además de la misma firma que
método base, el mismo tipo de retorno. Si se declara en una clase derivada un
método con otro tipo de dato como retorno, se generará un error en tiempo de
compilación.
Clase abstracta y clase concreta en Java
Recordar: Una clase base abstracta, es aquella que es definida para

especificar características generales que van a ser aprovechadas por sus clases
derivadas, pero no se necesita instanciar a dicha superclase.
Sintaxis para una clase abstracta:
abstract class ClaseAbstracta {

//código de la clase
}
Además, existe la posibilidad de contar con métodos abstractos:
Un método abstracto lleva la palabra revervada abstract y contiene sólo el

nombre y su firma. No necesita implementarse, ya que esto es tarea de las
subclases.

- 311 -
Si una clase contiene al menos un método abstracto, toda la clase es

considerada abstracta y debe de declararse como tal. Es posible claro, declarar a
una clase como abstracta sin que tenga métodos abstractos.
Ejemplo básico para un método abstracto:
abstract class ClaseAbstracta {
public abstract void noTengoCodigo( int x);
Si se crea una subclase de una clase que contiene un método abstracto,

deberá de especificarse el código de ese método; de lo contrario, el método
seguirá siendo abstracto y por consecuencia también lo será la subclase.41
Aunque no se pueden tener objetos de clases abstractas, si se pueden tener

referencias a objetos de esas clases, permitiendo una manipulación de objetos de
las clases derivadas mediante las referencias a la clase abstracta.
El uso de clases abstractas fortalece al polimorfismo, al poder partir de

clases definidas en lo general, sin implementación de código, pero pudiendo ser
agrupadas todas mediante variables de referencia a las clases base.
41
En C++, una clase se hace abstracta al declarar al menos uno de los métodos virtuales como puro.
- 312 -
Ejemplos de clases abstractas y polimorfismo:
Programa de cálculo de salario
// Clase base abstracta Employee
public abstract class Employee {

private String firstName;
private String lastName;
// Constructor
public Employee( String first, String last ) {
firstName = new String ( first );
lastName = new String( last );
}
public String getFirstName() {

return new String( firstName );
}
public String getLastName() {

return new String( lastName );
}
// el metodo abstracto debe de ser implementado por cada

// clase derivada de Employee para poder ser
// instanciadas las subclases
public abstract double earnings();
}
// Clase Boss class derivada de Employee
public final class Boss extends Employee {

private double weeklySalary;
public Boss( String first, String last, double s) {

super( first, last ); // llamada al constructor de
clase base
setWeeklySalary( s );
}
- 313 -
public void setWeeklySalary( double s ){

weeklySalary = ( s > 0 ? s : 0 );
}
// obtiene pago del jefe

public double earnings() {
return weeklySalary;
}

return "Jefe: " + getFirstName() + ' ' +
getLastName();
}
}
// Clase PieceWorker derivada de Employee
public final class PieceWorker extends Employee {

private double wagePerPiece; // pago por pieza
private int quantity; // piezas por semana
public PieceWorker( String first, String last,

double w, int q ) {
super( first, last );
setWage( w );
setQuantity( q );
}
public void setWage( double w ) {

wagePerPiece = ( w > 0 ? w : 0 );
}
public void setQuantity( int q ) {

quantity = ( q > 0 ? q : 0 );
}

return quantity * wagePerPiece;
}

- 314 -

return "Trabajador por pieza: " +
getFirstName() + ' ' + getLastName();
}
}
// Clase HourlyWorker derivada de Employee
public final class HourlyWorker extends Employee {

private double wage; // pago por hora
private double hours; // horas trabajadas por semana
public HourlyWorker( String first, String last,

double w, double h ) {
setWage( w );
setHours( h );
}
public void setWage( double w ) {

wage = ( w > 0 ? w : 0 );
}
public void setHours( double h ) {

hours = ( h >= 0 && h < 168 ? h : 0 );
}

return wage * hours;
}

return "Trabajador por hora: " +
}
}

- 315 -
// Clase CommissionWorker derivada de Employee
public final class CommissionWorker extends Employee {

private double salary; // salario base por semana
private double commission; // monto por producto vendido
private int quantity; // total de productos vendidos
por semana
public CommissionWorker( String first, String last,

double s, double c, int q) {
setSalary( s );
setCommission( c );
setQuantity( q );
}
public void setSalary( double s ) {

salary = ( s > 0 ? s : 0 );
}
public void setCommission( double c ) {

commission = ( c > 0 ? c : 0 );
}
public void setQuantity( int q ) {

quantity = ( q > 0 ? q : 0 );
}

return salary + commission * quantity;
}

return "Trabajador por Comision : " +
}
}

- 316 -
// Programa de ejemplo Polimorfismo
public class Polimorfismo {

public static void main( String rgs[] ) {
Employee ref; // referencia de clase base

Boss b;
CommissionWorker c;
PieceWorker p;
HourlyWorker h;
b = new Boss( "Vicente", "Fox", 800.00 );

c = new CommissionWorker( "Rosario", "Robles",
400.0, 3.0, 150);
p = new PieceWorker( "Andres Manuel", "Lopez Obrador",
2.5, 200 );
h = new HourlyWorker( "Ernesto", "Zedillo", 13.75, 40
);
ref = b; // referencia de superclase a objeto de

subclase
System.out.println( ref.toString() + " gano $" +
ref.earnings() );
System.out.println( b.toString() + " gano $" +
b.earnings() );
ref = c; // referencia de superclase a objeto de

subclase
ref.earnings() );
System.out.println( c.toString() + " gano $" +
c.earnings() );
ref = p; // referencia de superclase a objeto de

subclase
ref.earnings() );
System.out.println( p.toString() + " gano $" +
p.earnings() );

- 317 -
ref = h; // referencia de superclase a objeto de

subclase
ref.earnings() );
System.out.println( h.toString() + " gano $" +
h.earnings() );
}
}

- 318 -
Programa de figuras geométricas con una clase abstracta Shape (Forma)
// Definicion de clase base abstracta Shape
public abstract class Shape {
public double area() {

return 0.0;
}
public double volume() {

return 0.0;
}
public abstract String getName();

}
// Definicion de clase Point
public class Point extends Shape {

protected double x, y; // coordenadas del punto
public Point( double a, double b ) { setPoint( a, b ); }
public void setPoint( double a, double b ) {

x = a;
y = b;
}
public double getX() { return x; }
public double getY() { return y; }

{ return "[" + x + ", " + y + "]"; }
public String getName() {

return "Punto";
}
}

- 319 -
// Definicion de clase Circle
public class Circle extends Point { // hereda de Point

protected double radius;
public Circle() {
super( 0, 0 );
setRadius( 0 );
}
public Circle( double r, double a, double b ) {

super( a, b );
setRadius( r );
}
public void setRadius( double r )

{ radius = ( r >= 0 ? r : 0 ); }
public double getRadius() { return radius; }
public double area() { return 3.14159 * radius * radius; }

{ return "Centro = " + super.toString() +
"; Radio = " + radius; }

return "Circulo";
}
}
// Definicion de clase Cylinder
public class Cylinder extends Circle {

protected double height; // altura del cilindro
public Cylinder( double h, double r, double a, double b )

{
super( r, a, b );

- 320 -
setHeight( h );
}
public void setHeight( double h ){

height = ( h >= 0 ? h : 0 );
}
public double getHeight() {

return height;
}
public double area() {

return 2 * super.area() +
2 * 3.14159 * radius * height;
}
public double volume() {

return super.area() * height;
}
public String toString(){

return super.toString() + "; Altura = " + height;
}

return "Cilindro";
}
}
// Codigo de prueba
public class Polimorfismo02 {
public static void main (String args []) {

Point point;
Circle circle;
Cylinder cylinder;
Shape arrayOfShapes[];
point = new Point( 7, 11 );

- 321 -
circle = new Circle( 3.5, 22, 8 );

cylinder = new Cylinder( 10, 3.3, 10, 10 );
arrayOfShapes = new Shape[ 3 ];
// asigno las referencias de los objetos de subclase

// a un arreglo de superclase
arrayOfShapes[ 0 ] = point;
arrayOfShapes[ 1 ] = circle;
arrayOfShapes[ 2 ] = cylinder;
System.out.println( point.getName() + ": " +

point.toString());
System.out.println( circle.getName() + ": " +

circle.toString());
System.out.println( cylinder.getName() + ": " +

cylinder.toString());
for ( int i = 0; i < 3; i++ ) {

System.out.println( arrayOfShapes[ i ].getName() +
": " + arrayOfShapes[ i ].toString());
System.out.println( "Area = " + arrayOfShapes[ i
].area() );
System.out.println( "Volume = " + arrayOfShapes[ i
].volume() );
}
}
}

- 322 -
Ejemplo de Polimorfismo con una Interfaz en Java
Los programas anteriores estaban basados en clases y clases abstractas. Sin

embargo, también es posible tener variables de referencia a interfaces, a través de
las cuales se implemente el polimorfismo. El siguiente programa muestra otra
estructura clásica de clases “gráficas”, todas contienen su propia implementación
de draw(), y son organizadas en dos arreglos de ejemplo: uno de la clase
principal, y el segundo del tipo de la interfaz.
Ejemplo:
//programa Polimorfismo
interface IDrawable {
void draw();
}
class Shape implements IDrawable {

public void draw() { System.out.println("Dibujando
Figura."); }
}

- 323 -
class Circle extends Shape {

Circulo."); }
}
class Rectangle extends Shape {

Rectangulo."); }
}
class Square extends Rectangle {

cuadrado."); }
}
class Map implements IDrawable {

mapa."); }
}
public class Polimorfismo03 {

Shape[] shapes = {new Circle(), new Rectangle(), new
Square()};
IDrawable[] drawables = {new Shape(), new Rectangle(),
new Map()};
System.out.println("Dibujando figuras:");
for (int i = 0; i < shapes.length; i++)
shapes[i].draw();
System.out.println("Dibujando elementos dibujables:");

for (int i = 0; i < drawables.length; i++)
drawables[i].draw();
}
}

- 324 -
Polimorfismo en Ruby
El polimorfismo es implementado en Ruby a través de clases derivadas.
Recordar de nuevo: El polimorfismo se define como la capacidad de objetos de

clases diferentes, relacionados mediante herencia, a responder de forma distinta a
una misma llamada de un método.
Al hacer una solicitud de un método, a través de una variable, Ruby

determina en tiempo de ejecución a que método llamar, de acuerdo al tipo de
objeto al que se apunta.
Ejemplo:
#ejemplo Prueba
class Base
def quien
puts "base"
end
end
class Primera < Base

def quien
puts "primera"
end
end
class Segunda < Base

def quien
puts "segunda"
end
end
class Tercera < Base
end

- 325 -
class Cuarta < Base

def quien #Si se vale con un tipo de retorno diferente
(definido dinamicamente)
puts "cuarta"
return 1
end
end
#codigo de prueba
def prueba
objBase= Base.new
obj1= Primera.new
obj2= Segunda.new
obj3= Tercera.new
obj4= Cuarta.new
pBase=objBase
pBase.quien
pBase=obj1
pBase.quien
pBase=obj2
pBase.quien
pBase=obj3
pBase.quien
pBase=obj4
pBase.quien
end
prueba
Como se aprecia en el ejemplo anterior, en caso de que el método no sea

redefinido, se ejecuta el método de la clase base.
Es importante señalar que no es necesario que el tipo de retorno coincida,

pues éste se determina dinámicamente.

- 326 -
¿Y la clase abstracta?
Ruby no tiene el concepto de clase abstracta y clase concreta. Si por cuestión de

diseño es necesario definir una clase que no debe permitir instancias, es posible
crear un método en dicha clase como sigue:
class MiClase
def self.abstract?
return self == MiClase
end
end
Esto no limita realmente a que alguien pueda instanciar la clase, pero es

posible preguntar si la clase es “abstract?”.

- 327 -
Ejemplos de polimorfismo:
Programa de cálculo de salario
# Clase base Employee
class Employee
attr_reader :firstName, :lastName
@firstName
@lastName
def self.abstract?
return self == Employee
end
# Inicializador
def initialize (first, last)
@firstName = String.new( first )
@lastName = String.new( last )
end
# método sin código

def earnings
end
end
# Clase Boss cderivada de Employee
class Boss < Employee

@weeklySalary
def initialize (first, last, s)

super( first, last ) # llamada al constructor de
clase base
setWeeklySalary( s )
end
def setWeeklySalary( s )
@weeklySalary = ( s > 0 ? s : 0 )
- 328 -
end
# obtiene pago del jefe

def earnings
return @weeklySalary
end
def to_s
return "Jefe: " + @firstName + " " + @lastName
end
end
# Clase PieceWorker derivada de Employee
class PieceWorker < Employee

attr_reader :wagePerPiece, :quantity
@wagePerPiece # pago por pieza

@quantity # piezas por semana
def initialize(first, last, w, q )

super( first, last )
setWage( w )
setQuantity( q )
end
def setWage( w )
@wagePerPiece = ( w > 0 ? w : 0 )
end
def setQuantity( q )
@quantity = ( q > 0 ? q : 0 )
end
def earnings
return quantity * wagePerPiece
end
def to_s
return "Trabajador por pieza: " + @firstName + " " +

- 329 -
@lastName
end
end
# Clase HourlyWorker derivada de Employee
class HourlyWorker < Employee

attr_reader :wage, :hours
@wage # pago por hora

@hours # horas trabajadas por semana
def initialize(first, last, w, h)

setWage( w )
setHours( h )
end
def setWage( w )
@wage = ( w > 0 ? w : 0 )
end
def setHours( h )
@hours = ( h >= 0 && h < 168 ? h : 0 )
end
def earnings
return @wage * @hours
end
def to_s
return "Trabajador por hora: " + @firstName + " " +
@lastName
end
end
# Clase CommissionWorker derivada de Employee
class CommissionWorker < Employee

- 330 -
attr_reader :salary, :commission, :quantity
@salary # salario base por semana

@commission # monto por producto vendido
@quantity # total de productos vendidos por semana
def initialize(first, last, s, c, q)

setSalary( s )
setCommission( c )
setQuantity( q )
end
def setSalary( s )
@salary = ( s > 0 ? s : 0 )
end
def setCommission( c )
@commission = ( c > 0 ? c : 0 )
end
def setQuantity( q )
@quantity = ( q > 0 ? q : 0 )
end
def earnings
return @salary + @commission * @quantity
end
def to_s
return "Trabajador por Comision : " + @firstName + " "
+ @lastName
end
end
# Codigo de ejemplo Polimorfismo
b = Boss.new( "Vicente", "Fox", 800.00 )

c = CommissionWorker.new( "Rosario", "Robles", 400.0, 3.0,

- 331 -
150)
p = PieceWorker.new( "Andres Manuel", "Lopez Obrador", 2.5,
200 )
h = HourlyWorker.new( "Ernesto", "Zedillo", 13.75, 40 )
puts Employee.abstract?
ref = b # referencia a objeto de subclase

puts ref.to_s + " gano $" + ref.earnings.to_s
puts b.to_s + " gano $" + b.earnings.to_s
ref = c # referencia a objeto de subclase

puts c.to_s + " gano $" + c.earnings.to_s
ref = p # referencia a objeto de subclase

puts p.to_s + " gano $" + p.earnings.to_s
ref = h # referencia a objeto de subclase

puts h.to_s + " gano $" + h.earnings.to_s

- 332 -
Programa de figuras geométricas con una clase abstracta Shape (Forma)
# Definicion de clase base abstracta Shape
class Shape
def self.abstract?
return self == Shape
end
def area
return 0.0
end
def volume
return 0.0
end
def getName
end
end
# Definicion de clase Point
class Point < Shape

attr_reader :x, :y
@x
@y # coordenadas del punto
def initialize (a, b)

setPoint( a, b )
end
def setPoint(a, b)
@x, @y = a, b
end
def to_s
return "[" + @x.to_s + ", " + @y.to_s + "]"

- 333 -
end
def getName
return "Punto"
end
end
# Definicion de clase Circle

class Circle < Point # hereda de Point
attr_reader :radius
@radius
def initialize(r, a, b)
super( a, b )
setRadius( r )
end
def setRadius(r)
@radius = ( r >= 0 ? r : 0 )
end
def area
return 3.14159 * radius * radius
end
def to_s
return "Centro = " + super + "; Radio = " +
@radius.to_s
end
def getName
return "Circulo "
end
end
# Definicion de clase Cylinder

class Cylinder < Circle
attr_reader :height
alias_method :areaCircle, :area #define un nuevo nombre

- 334 -
para el metodo area de Circle

# o puede usarse alias :areaCircle :area
@height # altura del cilindro
def initialize(h, r, a, b)
super(r, a, b)
setHeight(h)
end
def setHeight(h)
@height = ( h >= 0 ? h : 0 )
end
def area
return 2 * super + 2 * 3.14159 * @radius * @height
end
def volume
return areaCircle * @height
end
def to_s
return super + "; Altura = " + @height.to_s
end
def getName
return "Cilindro "
end
end
# Codigo de prueba
point = Point.new( 7, 11 )
circle = Circle.new( 3.5, 22, 8 )
cylinder = Cylinder.new( 10, 3.3, 10, 10 )
# asigno las referencias de los objetos de subclase

# a un arreglo

- 335 -
arrayOfShapes=[]
arrayOfShapes[0 ] = point
arrayOfShapes[1 ] = circle
arrayOfShapes[2 ] = cylinder
puts point.getName + ": " + point.to_s
puts circle.getName + ": " + circle.to_s
puts cylinder.getName + ": " + cylinder.to_s
for elem in arrayOfShapes

puts elem.getName + elem.to_s
puts " Area = " + elem.area.to_s
puts " Volumen = " + elem.volume.to_s
end

- 336 -
Plantillas de clase en C++
El concepto de plantillas es aplicable también a la programación orientada a

objetos en C++a través de plantillas de clase. Estas favorecen la reutilización de
software, permitiendo que se generen objetos específicos para un tipo a partir de
clases genéricas. Las plantillas de clase también son llamadas clases
parametrizadas.
El uso de plantillas de clase no es diferente al uso de plantillas en

operaciones no orientadas a objetos:
template <class T> ó template <typename T>
Veamos el ejemplo clásico de un programa de pila aprovechando el uso de

plantillas.
Ejemplo:
// stack.h
// Clase de plantilla Pila
#ifndef STACK_H_
#define STACK_H_
//#include <iostream>
template< class T >

class Stack {
public:
Stack( int = 10 );
~Stack() { delete [] stackPtr; }
char push( const T& );
char pop( T& );
private:
int size;
int top;
T *stackPtr;

- 337 -
char isEmpty() const { return top == -1; }

char isFull() const { return top == size - 1; }
};
template< class T >

Stack< T >::Stack( int s )
{
size = s > 0 ? s : 10;
top = -1;
stackPtr = new T[ size ];
}
template< class T >

char Stack< T >::push( const T &pushValue )
{
if ( !isFull() ) {
stackPtr[ ++top ] = pushValue;
return 1;
}
return 0;
}
template< class T >

char Stack< T >::pop( T &popValue )
{
if ( !isEmpty() ) {
popValue = stackPtr[ top-- ];
return 1;
}
return 0;
}
#endif /*STACK_H_*/

- 338 -
// Ejemplo uso de plantillas de clase

#include <iostream>
#include "stack.h"
int main() {
Stack< double > doubleStack( 5 );
double f = 1.1;
cout << "Insertando elementos en doubleStack \n";
while ( doubleStack.push( f ) ) {
cout << f << ' ';
f += 1.1;
}
cout << "\nLa pila está llena. No se puede insertar el

elemento " << f
<< "\n\nSacando elementos de doubleStack\n";
while ( doubleStack.pop( f ) )
cout << f << ' ';
cout << "\nLa pila está vacía. No se pueden eliminar más

elementos\n";
Stack< int > intStack;

int i = 1;
cout << "\nInsertando elementos en intStack\n";
while ( intStack.push( i ) ) {
cout << i << ' ';
++i;
}
cout << "\nLa pila está llena. " << i

<< "\n\nSacando elementos de intStack\n";
while ( intStack.pop( i ) )
cout << i << ' ';

- 339 -
cout << "\nLa pila está vacía. No se pueden eliminar más

elementos \n";
return 0;
}
Las plantillas de clase ayudan a la reutilización de código, al permitir varias

versiones de clases para un tipo de dato a partir de clases genéricas. A estas clases
específicas se les conoce como clases de plantilla.
Con respecto a la herencia en combinación con el uso de plantillas, se deben

tener en cuenta las siguientes situaciones [21]:
• Una plantilla de clase se puede derivar de una clase de plantilla.
• Una plantilla de clase se puede derivar de una clase que no sea plantilla.
• Una clase de plantilla se puede derivar de una plantilla de clase.
• Una clase que no sea de plantilla se puede derivar de una plantilla de clase.
En cuanto a los miembros estáticos, cada clase de plantilla que se crea a

partir de una plantilla de clases mantiene sus propias copias de los miembros
estáticos.

- 340 -
Standard Template Library (STL)
Las plantillas de clase son una herramienta muy poderosa en C++. Esto ha
llevado a desarrollar lo que se conoce como STL. STL es el acrónimo de
Standard Template Library, y es una libreria de C++ que proporciona un conjunto
de clases contenedoras, iteradores y de algoritmos genericos:
• Las clases contenedoras incluyen vectores, listas, deques, conjuntos,

multiconjuntos, multimapas, pilas, colas y colas de prioridad.
• Los iteradotes son generalizaciones de apuntadores: son objetos que apuntan
a otros objetos. Son usados normalmente para iterar sobre un conjunto de
objetos. Los iteradotes son importantes porque son tipicamente usados como
interfaces entre las clases contenedores y los algoritmos.
• Los algoritmos genéricos incluyen un amplio rango de algoritmos
fundamentales para los más comunes tipos de manipulación de datos, como
ordenamiento, búsqueda, copiado y transformación.
• STL es una biblioteca estandar de ANSI/ISO desde julio de 1994.
La STL está altamente parametrizada, por lo que casi cada componente en la STL
es una plantilla [22]. Podemos usar por ejemplo la plantilla vector<T> para
hacer uso de vectores sin necesidad de preocuparnos del manejo de memoria:
vector<int> v(3); // Declara un vector de 3 elementos.

v[0] = 7;
v[1] = v[0] + 3;
v[2] = v[0] + v[1]; // v[0] == 7, v[1] == 10, v[2] == 17
Los algoritmos proporcionados por la STL ayudan a manipular los datos de los
contenedores [22]. Por ejemplo, podemos invertir el orden de los elementos de un
vector, usando el algoritmo reverse():
reverse(v.begin(), v.end()); // v[0]==17, v[1]==10, v[2]==7

- 341 -
Ejemplo:
#ifndef STACK_HPP_
#define STACK_HPP_
#include <vector>
template <typename T>

class Stack {
private:
std::vector<T> elems; // elementos
public:
void push(T const&);
void pop();
T top() const; // regresa elemento en el tope
bool empty() const { // regresa si la pila esta vacia
return elems.empty();
}
};

void Stack<T>::push (T const& elem)
{
elems.push_back(elem); // añade una copia de elem
}
template<typename T>
void Stack<T>::pop ()
{
if (elems.empty()) {
std::cout<<"Stack<>::pop(): pila vacia";
return;
}
elems.pop_back(); // remueve el ultimo elemento
}

T Stack<T>::top () const
{
if (elems.empty()) {

- 342 -
std::cout<<"Stack<>::top(): pila vacia";

}
return elems.back(); // regresa copia del elemento en
el tope
}
#endif /*STACK_HPP_*/
#include <iostream>
#include <string>
#include <cstdlib>
#include "stack.hpp"
int main()
{
Stack<int> intStack; // pila de enteros
Stack<std::string> stringStack; // pila de strings
// manipulapila de enteros
intStack.push(7);
std::cout << intStack.top() << std::endl;
// manipula pila de strings

stringStack.push("hola");
std::cout << stringStack.top() << std::endl;
stringStack.pop();
stringStack.pop();
}

- 343 -
Clases Genéricas en Java
Java 1.5 introdujo finalmente el uso de clases genéricas (generics) [23]. El

uso de clases genéricas es una característica poderosa usada en otros lenguajes,
siendo C++ el ejemplo más conocido que soporta programación genérica
mediante el uso de plantillas o templates.
Sintaxis:
class NombreClase <Lista de parámetros de tipos> { … }
Ejemplo:
class Pair<T, U> {
private final T first;
private final U second;
public Pair(T first, U second) { this.first=first;
this.second=second; }
public T getFirst() { return first; }
public U getSecond() { return second; }
}
public class PairExample {

Pair<String, Integer> pair = new Pair<String,

Integer>("one",2);
// no acepta tipos de datos básicos o primitivos

//Pair<String, int> pair2 = new Pair<String,
Integer>("one",2);
// siguiente linea generaría un warning de seguridad

de tipos
//Pair<String, Integer> pair3 = new Pair("one",2);
System.out.println("Obtén primer elemento:" +

pair.getFirst());
- 344 -
System.out.println("Obtén segundo elemento:" +

pair.getSecond());
}
}
Un error común es olvidar los parámetros de tipo al invocar el constructor:
Pair<String, Integer> pair = new Pair("one",2);
Esto produce un warning pero no un error. Es legal pero Pair es tomado como un
tipo “crudo” (raw type)42, pero la conversión de ese tipo de dato al tipo
parametrizado es lo que genera el warning.
Es también posible parametrizar interfaces, como se muestra a continuación.
Sintaxis:
interface NombreInterfaz <Lista de parámetros de tipos> { … }
Ejemplo:
interface IPair<T, U>{
public T getFirst();
public U getSecond();
}
class Pair<T, U> implements IPair<T, U>{

private final T first;
private final U second;
public Pair(T first, U second) { this.first=first;
this.second=second; }
public T getFirst() { return first; }
public U getSecond() { return second; }
}
42
Un raw type es un tipo especial de dato creado para facilitar la transición de código antiguo al nuevo
código soportando Generics.
Ver: http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#110257
- 345 -
public class PairExample {

IPair<String, Integer> ipair = new Pair<String,

Integer>("one",2);
System.out.println("Obtén primer
elemento:"+ipair.getFirst());
System.out.println("Obtén segundo
elemento:"+ipair.getSecond());
}
Un requerimiento para el uso tipos genéricos en Java es que no pueden usarse tipo
de datos primitivos, porque los tipos primitivos o básicos no son subclases de
Object [24]. Por lo que sería ilegal por ejemplo querer instanciar Pair<int,
String> . La ventaja es que el uso de la clase Object significa que solo un
archivo de clase (.class) necesita ser generado por cada clase genérica [25].

- 346 -
Biblioteca de Clases Genéricas en Java
Al igual que C++ con la STL, Java tiene un conjunto de clases genéricas
predefinidas. Su uso, al igual con las clases genéricas definidas por el
programador, no esta permitido para tpos primitivos, por lo que solo objetos
podrán ser contenidos. Las principales clases genéricas en Java son, como en la
STL, clases contenedoras o collecciones43. El Java Collections Framework (JCF)
es un conjunto de interfaces y clases definidos en los paquetes java.util y
java.util.concurrent.
Las interfaces del JCF son:
• Collection. Contiene la funcionalidad básica requerida en casi cualquier

colección de objetos (con excepción de Map)
• Set. Es una colección sin duplicados, donde el orden es no significante. Sin
embargo contiene un método que devuelve el conjunto ordenado
(SortedSet).
• Queue. Define el comportamiento básico de una estructura de cola.
• List. Es una colección donde el orden es significativo, permitiendo además
valores duplicados.
• Map. Define una colección donde un valor clave es asociado para almacenar
y recuperar elementos.
La siguiente figura muestra las principales interfaces de la JCF [26]:
43
Las colecciones en Java eran implementadas antes de la versión 1.5 pero sin el uso de clases genéricas. El
uso de versiones anteriores de colecciones con colecciones genéricas es permitido por compatibilidad hacia
atrás pero debe tenerse especial cuidado pues hay situaciones que el compilador no puede validar.
- 347 -
Ejemplo:
// Usando la interfaz Collection

import java.util.List;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest {

private static final String[] colors =
{ "MAGENTA", "RED", "WHITE", "BLUE", "CYAN" };
private static final String[] removeColors =
{ "RED", "WHITE", "BLUE" };
// crea ArrayList, añade Colors y la manipula

public CollectionTest() {
List< String > list = new ArrayList< String >();
List< String > removeList = new ArrayList< String >();
// añade elementos del arreglo colors a list

for ( String color : colors )
list.add( color );
// añade elementos del arreglo removeColors a

removeList
- 348 -
for ( String color : removeColors )

removeList.add( color );
System.out.println( "ArrayList: " );
// despliega contenido de list

for ( int count = 0; count < list.size(); count++ )
System.out.printf( "%s ", list.get( count ) );
// remueve de list colores contenidos en removeList

removeColors( list, removeList );
System.out.println( "\n\nArrayList después de llamar

removeColors: " );
// despliega contenido de list

for ( String color : list )
System.out.printf( "%s ", color );
} // end CollectionTest constructor
// remueve colores especificados en collection2 de

collection1
private void removeColors(
Collection< String > collection1, Collection< String >
collection2 ) {
// obtiene iterator
Iterator< String > iterator = collection1.iterator();
// mientras colección tiene elementos

while ( iterator.hasNext() )
if ( collection2.contains( iterator.next() ) )
iterator.remove(); // remueve color actual
}
public static void main( String args[] ) {

new CollectionTest();
}

- 349 -
Manejo de Excepciones
Siempre se ha considerado importante el manejo de los errores en un

programa, pero no fue hasta que surgió el concepto de manejo de excepciones que
se dio una estructura más formal para hacerlo.
El término de excepción viene de la posibilidad de detectar eventos que no

forman parte del curso normal del programa, pero que de todas formas ocurren.
Un evento "excepcional" puede ser generado por una falla en la conexión a

red, un archivo que no puede encontrarse, o un acceso indebido en memoria. La
intención de una excepción es responder de manera dinámica a los errores, sin
que afecte gravemente la ejecución de un programa, o que al menos se controle la
situación posterior al error.
¿Cuál es la ventaja con respecto al manejo común de errores?
Normalmente, cada programador agrega su propio código de manejo de

errores y queda revuelto con el código del programa. El manejo de excepciones
indica claramente en que parte se encuentra el manejo de los errores, separándolo
del código normal.
Además, es posible recibir y tratar muchos de los errores de ejecución y

tratarlos correctamente, como podría ser una división entre cero.
Se recomienda el manejo de errores para aquellas situaciones en las cuales

el programa necesita ayuda para recuperarse.

- 350 -
Manejo de Excepciones en C++
El manejo de excepciones en C++, involucra los siguientes elementos

sintácticos:
• try. El bloque definido por la instrucción try, especifica el código que

potencialmente podría generar un error que deba ser manejado por la
excepción:
try
{
// instrucciones donde las excepciones
// pueden ser generadas
}
• throw: Esta instrucción seguida por una expresión de un cierto tipo, genera
una excepción del tipo de la expresión. Esta instrucción debería ser
ejecutada dentro de algún bloque try, de manera directa o indirecta:
throw "Se genera una excepción de tipo char *";
• catch: La instrucción catch va seguida de un bloque try. Catch define un

segmento de código para tratar una excepción (de un tipo) lanzada:
catch (char *mensaje)
{
// instrucciones donde la excepción
// thrown char *
// será procesada
}

- 351 -
Ejemplo:
// exceptions
#include <iostream>
int main () {
try
{
throw 20;
}
catch (int e)
{
cout << "Una excepción ocurrió. Número: " << e << endl;
}
return 0;
}
Excepciones estandar en C++
La biblioteca estándar de C++ proporciona una clase base diseñada

específicamente para declarar objetos que pueden ser lanzados como excepciones.
La clase exception esta declarada en <exception> (en el espacio de nombres std).
La clase tiene entre otras cosas un método virtual llamado what que regresa un
arreglo de caracteres y puede ser redefinida en clases derivadas para describir la
excepción.
Ejemplo:
// excepciones estándar
#include <iostream>
#include <exception>
class myexception: public exception

{
virtual const char* what() const throw()
{
- 352 -
return "Mi excepción se ejecutó";

}
} myex;
int main () {
try
{
throw myex;
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
Las clases de la biblioteca estándar implementan clases derivadas de la clase

exception para poder lanzar excepciones derivadas de esta clase.
Ejemplo:
// excepción bad_alloc
#include <iostream>
#include <exception>
int main () {
try
{
int* myarray= new int[1000];
}
catch (exception& e)
{
cout << "Excepción estándar: " << e.what() << endl;
}
return 0;
}

- 353 -
Manejo de Excepciones en Java
El modelo de excepciones de Java es similar al de C y C++, pero mientras

en estos lenguajes no estamos obligados a manejar las excepciones, en Java es
forzoso para el uso de ciertas clases; de lo contrario, el compilador generará un
error.
¿Cómo funciona?
Muchas tipos de errores pueden provocar una excepción, desde un

desbordamiento de memoria o un disco duro estropeado hasta un intento de
dividir por cero o intentar acceder a un arreglo fuera de sus límites. Cuando esto
ocurre, la máquina virtual de Java crea un objeto de la clase Exception ó Error y
se notifica el hecho al sistema de ejecución. En este punto, se dice que se ha
lanzado una excepción.
Un método se dice que es capaz de tratar una excepción si ha previsto el

error que se ha producido y prevé también las operaciones a realizar para
“recuperar” el programa de ese estado de error.
En el momento en que es lanzada una excepción, la máquina virtual de Java
recorre la pila de llamadas de métodos en busca de alguno que sea capaz de tratar
la clase de excepción lanzada. Para ello, comienza examinando el método donde
se ha producido la excepción; si este método no es capaz de tratarla, examina el
método desde el que se realizó la llamada al método donde se produjo la
excepción y así sucesivamente hasta llegar al último de ellos. En caso de que
ninguno de los métodos de la pila sea capaz de tratar la excepción, la máquina
virtual de Java muestra un mensaje de error y el programa termina.
Los programas escritos en Java también pueden lanzar excepciones
explícitamente mediante la instrucción throw, lo que facilita la devolución de un
código de error al método que invocó el método que causó el error.
Un ejemplo de una excepción generada (y no tratada) es el siguiente
programa:
- 354 -
public class Excepcion {

int i=5, j=0;
int k=i/j; // División por cero
}
}
Al ejecutarlo, se verá que la máquina virtual Java ha detecta una condición

de error y ha crea un objeto de la clase java.lang.ArithmeticException. Como el
método donde se ha producido la excepción no es capaz de tratarla, es manejada
por la máquina virtual Java, que muestra un mensaje de error y finaliza la
ejecución del programa.
Lanzamiento de excepciones (throw)
Como se ha comentado anteriormente, un método también es capaz de

lanzar excepciones.
Sintaxis:
método ( ) throws <lista de excepciones> {

//código
...
throw new <nombre Excepción>
...
}
donde <lista de excepciones> es el nombre de cada una de las excepciones

que el método puede lanzar.
Por ejemplo, en el siguiente programa se genera una condición de error si el

dividendo es menor que el divisor:

- 355 -
Ejemplo:
public class LanzaExcepcion {
public static void main(String argumentos[]) throws
ArithmeticException {
int i=1, j=0;

if (j==0)
throw new ArithmeticException();
else
System.out.println(i/j);
}
}
Para lanzar la excepción es necesario crear un objeto de tipo Exception o

alguna de sus subclases (por ejemplo: ArithmeticException) y lanzarlo mediante
la instrucción throw.
Los dos ejemplos vistos anteriormente, son capaces de lanzar una excepción
en un momento dado, pero hasta aquí no difieren en mucho en su ejecución, ya
que el resultado finalmente es la terminación del programa. En la siguiente
sección se menciona como podemos darles un manejo especial a las excepciones,
de tal forma que el resultado puede ser previsto por el programador.
Manejo de excepciones
En Java, de forma similar a C++ se pueden tratar las excepciones previstas

por el programador utilizando unos mecanismos, los manejadores de
excepciones, que se estructuran en tres bloques:
• El bloque try.
• El bloque catch.
• El bloque finally.
Un manejador de excepciones es una porción de código que se va a encargar

de tratar las posibles excepciones que se puedan generar.
- 356 -
El bloque try
Lo primero que hay que hacer para que un método sea capaz de tratar una
excepción generada por la máquina virtual Java o por el propio programa
mediante una instrucción throw, es encerrar las instrucciones susceptibles de
generarla en un bloque try.
try {
<instrucciones>
}
…
Cualquier excepción que se produzca dentro del bloque try será analizada
por el bloque o bloques catch que se verá en el punto siguiente. En el momento en
que se produzca la excepción, se abandona el bloque try y, por lo tanto, las
instrucciones que sigan al punto donde se produjo la excepción no serán
ejecutadas.
El bloque catch
Cada bloque try debe tener asociado por lo menos un bloque catch.
try {
<instrucciones>
} catch (TipoExcepción1 nombreVariable1) {
<instruccionesBloqueCatch1>
} catch (TipoExcepción2 nombreVariable2) {
}
...
catch (TipoExcepciónN nombreVariableN) {
<instruccionesBloqueCatchN>
}
Por cada bloque try pueden declararse uno o varios bloques catch, cada uno
de ellos capaz de tratar un tipo de excepción.
- 357 -
Para declarar el tipo de excepción que es capaz de tratar un bloque catch, se

declara un objeto cuya clase es la clase de la excepción que se desea tratar o una
de sus superclases.
Ejemplo:
public class ExcepcionTratada {
int i=5, j=0;
try {
int k=i/j;
System.out.println("Esto no se va a ejecutar.");
}
catch (ArithmeticException ex) {
System.out.println("Ha intentado dividir por
cero");
}
System.out.println("Fin del programa");
}
}
La ejecución se resuelve de la siguiente forma:
1. Cuando se intenta dividir por cero, la máquina virtual Java genera un

objeto de la clase ArithmeticException.
2. Al producirse la excepción dentro de un bloque try, la ejecución del
programa se pasa al primer bloque catch.
3. Si la clase de la excepción se corresponde con la clase o alguna
subclase de la clase declarada en el bloque catch, se ejecuta el bloque
de instrucciones catch y a continuación se pasa el control del
programa a la primera instrucción a partir de los bloques try-catch.
También se podría haber utilizado en la declaración del bloque catch, una

superclase de la clase ArithmeticException.

- 358 -
Por ejemplo:
catch (RuntimeException ex)

ó
catch (Exception ex)
Sin embargo, es mejor utilizar excepciones más cercanas al tipo de error

previsto, ya que lo que se pretende es recuperar al programa de alguna condición
de error y si tratan de capturar todas las excepciones de una forma muy general,
posiblemente habrá que averiguar después qué condición de error se produjo para
poder dar una respuesta adecuada.
El bloque finally
El bloque finally se utiliza para ejecutar un bloque de instrucciones sea cual

sea la excepción que se produzca. Este bloque se ejecutará en cualquier caso,
incluso si no se produce ninguna excepción.
Este bloque garantiza que el código que contiene será ejecutado

independientemente de que se genere o no una excepción:
try {
<instrucciones>
}
catch (TipoExcepción1 nombreVariable1) {
}
catch (TipoExcepción2 nombreVariable2) {

}
...
catch (TipoExcepciónN nombreVariableN) {
<instruccionesBloqueCatchN>
}
finally {
<instruccionesBloqueFinally>
}

- 359 -
Es utilizado para no tener que repetir código en el bloque try y en los

bloques catch. Este código sirve para llevar a buen término el bloque de código
independientemente del resultado.
Veamos ahora la clase ExcepcionTratada con el bloque finally:

public class ExcepcionTratada {
int i=5, j=0;
try {
int k=i /* /j */;//probar con y sin error
}
catch (ArithmeticException ex) {
System.out.println("Ha intentado dividir por
cero");
}
finally {
System.out.println("Salida de finally");
}
System.out.println("Fin del programa");
}
}
Un ejemplo derivando la clase Exception de Java en un estilo similar al uso de la

clase correspondiente en C++:
class DivisionByZeroException extends Exception {

DivisionByZeroException(String msg) { super(msg); }
}
public class DivisionByZero {

public void division() throws DivisionByZeroException {
int num1 = 10;
int num2 = 0;
if (num2 == 0)
throw new DivisionByZeroException("/ entre 0");

- 360 -
System.out.println(num1 + " / " + num2 + " = " + (num1

/ num2));
System.out.println("terminando division().");
}

try {
new DivisionByZero().division();
} catch (DivisionByZeroException e) {
System.out.println("En main, tratando con " + e);
} finally {
System.out.println("Finally ejecutado en main.");
}
System.out.println("Finalizando main.");
}
}
Jerarquía de excepciones
Las excepciones son objetos pertenecientes a la clase Throwable o alguna

de sus subclases.
Dependiendo del lugar donde se produzcan existen dos tipos de excepciones:
1. Las excepciones síncronas no son lanzadas en un punto arbitrario del

programa sino que, en cierta forma, son previsibles en determinados puntos
del programa como resultado de evaluar ciertas expresiones o la invocación
de determinadas instrucciones o métodos.
2. Las excepciones asíncronas pueden producirse en cualquier parte del

programa y no son tan previsibles. Pueden producirse excepciones
asíncronas debido a dos razones:
• La invocación del método stop() de la clase Thread que se está

ejecutando.
• Un error interno en la máquina virtual Java.

- 361 -
Dependiendo de si el compilador comprueba o no que se declare un

manejador para tratar las excepciones, se pueden dividir en:
1. Las excepciones comprobables son repasadas por el compilador Java

durante el proceso de compilación, de forma que si no existe un manejador
que las trate, generará un mensaje de error.
2. Las excepciones no comprobables son la clase RuntimeException y sus
subclases junto con la clase Error y sus subclases.
También pueden definirse por el programador subclases de las excepciones

anteriores. Las más interesantes desde el punto de vista del programador son las
subclases de la superclase Exception ya que éstas pueden ser comprobadas por el
compilador.
La jerarquía completa de excepciones existentes en el paquete java.lang se

puede consultar más adelante.44
Ventajas del tratamiento de excepciones
Las ventajas, mencionadas por Díaz-Alejo [27], de un mecanismo de

tratamiento de excepciones como este son varias:
• Separación del código “útil” del tratamiento de errores.

• Propagación de errores a través de la pila de métodos.
• Agrupación y diferenciación de errores mediante jerarquías.
• Claridad del código y obligación del tratamiento de errores.
44
Para un listado actual ver la documentación del jdk de Java más reciente.

- 362 -
Lista de Excepciones 45
La jerarquía de clases derivadas de Error existentes en el paquete java.lang

es la siguiente:
o java.lang.Object
o java.lang.Throwable (implements java.io.Serializable)
o java.lang.Error
o java.lang.AssertionError
o java.lang.LinkageError
o java.lang.ClassCircularityError
o java.lang.ClassFormatError
o java.lang.UnsupportedClassVersionError
o java.lang.ExceptionInInitializerError
o java.lang.IncompatibleClassChangeError
o java.lang.AbstractMethodError
o java.lang.IllegalAccessError
o java.lang.InstantiationError
o java.lang.NoSuchFieldError
o java.lang.NoSuchMethodError
o java.lang.NoClassDefFoundError
o java.lang.UnsatisfiedLinkError
o java.lang.VerifyError
o java.lang.ThreadDeath
45
Lista obtenida de la documentación del jdk en su versión 1.6
- 363 -
o java.lang.VirtualMachineError
o java.lang.InternalError
o java.lang.OutOfMemoryError
o java.lang.StackOverflowError
o java.lang.UnknownError
La jerarquía de clases derivadas de Exception existentes en el paquete

java.lang es la siguiente:
o java.lang.Object
o java.lang.Throwable (implements java.io.Serializable)
o java.lang.Exception
o java.lang.ClassNotFoundException
o java.lang.CloneNotSupportedException
o java.lang.IllegalAccessException
o java.lang.InstantiationException
o java.lang.InterruptedException
o java.lang.NoSuchFieldException
o java.lang.NoSuchMethodException
o java.lang.RuntimeException
o java.lang.ArithmeticException
o java.lang.ArrayStoreException
o java.lang.ClassCastException
o java.lang.EnumConstantNotPresentException
o java.lang.IllegalArgumentException

- 364 -
o java.lang.IllegalThreadStateException
o java.lang.NumberFormatException
o java.lang.IllegalMonitorStateException
o java.lang.IllegalStateException
o java.lang.IndexOutOfBoundsException
o java.lang.ArrayIndexOutOfBoundsException
o java.lang.StringIndexOutOfBoundsException
o java.lang.NegativeArraySizeException
o java.lang.NullPointerException
o java.lang.SecurityException
o java.lang.TypeNotPresentException
o java.lang.UnsupportedOperationException
Las principales excepciones en otros paquetes Java son:
o class java.lang.Object
o class java.lang.Throwable
o class java.lang.Error
o java.awt.AWTError
o class java.lang.Exception
o java.io.IOException
o java.io.EOFException
o java.io.FileNotFoundException
o java.io.InterruptedIOException
o java.io.UTFDataFormatException
o java.net.MalformedURLException
o java.net.ProtocolException
o java.net.SocketException
o java.net.UnknownHostException
- 365 -
o java.net.UnknownServiceException
o RuntimeException
o java.util.EmptyStackException
o java.util.NoSuchElementException
o java.awt.AWTException

- 366 -
Afirmaciones en Java
Las afirmaciones son usadas para verificar invariantes en un programa [28].

Es una manera simple de probar una condición que siempre debe ser verdadera.
Si la afirmación resulta ser falsa una excepción es lanzada. Escribir afirmaciones
mientras se programa es una de las más rápidas y efectivas formas de detectar y
corregir errores [29]. Las afirmaciones fueron introducidas en Java desde la
versión 1.4 del jdk.
Las afirmaciones por lo tanto son usadas para comprobar código que se
asume será verdadero, siendo la afirmación la parte responsable de verificar que
realmente es verdadero. Cada afirmación debe contener una expresión boleana
(boolean o Boolean).
Sintaxis:
assert Expression1;
ó:
assert Expression1 : Expression2 ;
donde Expression1 es una expresión booleana. Esta expresión es la

evaluada y si es falsa la excepción AssertionError es lanzada. Expression2 es
una expresión que devuelve un valor (no void) que generalmente es usado para
proveer de un mensaje para la excepción AssertionError.
Usando afirmaciones
Es importante no introducir código en las afirmaciones que en realidad sea

una acción del programa. Por ejemplo:

- 367 -
assert ++i < max;
Es inapropiado pues se esta modificando el estado del programa al mismo

tiempo que validando. Lo correcto sería algo del estilo:
i++;
assert i < max;
Errores detectados con afirmaciones deben ser errores que no deben pasar.
Es por esto que se lanza un subtipo de Error en lugar de un subtipo de Exception.
Si falla la validación de una afirmación se asume un error grave que nunca debe
pasar.
Habilitando y deshabilitando las afirmaciones
Por omisión, las afirmaciones estan deshabilitadas en tiempo de ejecución.

Para cambiar de un estado a otro deben aplicarse parámetros especiales en la
ejecución de la máquina virtual de Java:
-enableassertions | -ea
-disableassertions | -da
Estos modificadores pueden no llevar a su vez argumentos, por lo que active

o desactiva las afirmaciones para todas las clases, o pueden indicarse nombres de
paquetes ó clases específicas:
java [-ea | -da]:[paquete | clase] Clase
Las clases del sistema no son directamente afectadas por estos

modificadores, lo que es deseable, por lo que si se quiere modificar esto se deben
usar:
-enablesystemassertions | –esa
-disablesystemassertions | -dsa.

- 368 -
Ejemplo:
//Recuerda habilitar el uso de afirmaciones
import java.io.IOException;
public class AssertionTest {
public static void main(String argv[]) throws IOException {

System.out.print("Introduce tu estado civil: ");
int c = System.in.read();
switch ((char) c) {
case 's':
case 'S': System.out.println("Soltero"); break;
case 'c':
case 'C': System.out.println("Casado"); break;
case 'd':
case 'D': System.out.println("Divorciado"); break;
default: assert !true: "Opción inválida";; break;
}
}
}

- 369 -
Manejo de Excepciones en Ruby
Ruby soporta el manejo de excepciones como cualquier lenguaje actual de

programación. El manejo de excepciones en Ruby, involucra los siguientes
elementos sintácticos:
Raise & Rescue
La ejecución de raise produce una excepción. raise es un método del

módulo Kernel y tiene un alias definido como fail. La sintaxis se presenta a
continuación:
raise ExceptionClass[, "message"]
Ejemplos:
raise # se relanza la ultima excepcion

raise "Danger, Will Robinson!"
raise “Houston, we have a problem”
raise ArgumentError, "Falla de datos"
raise ArgumentError.new("Falla de datos")
raise "Falta nombre" if nombre.nil?
Ahora, como agrupamos un segmento de código en el cual se quieren manejar

excepciones? Podemos agrupar el código usando un bloque begin end. Dentro
podemos incluir la claúsula rescue, por ejemplo:
begin
expr..
[rescue [tipo_de_error [=> var],..]
expr..]..
[else
expr..]
[ensure
expr..]
end

- 370 -
La sintaxis anterior implica que podemos poner una serie de clausulas rescue
especificando diferentes tipos de errores que pueden ser “rescatados” y la clausula
else recibiría aquellos errores que no entren dentro de los especificados por
rescue.
La clansula ensure es usada para especificar código que queremos que se ejecute
independientemente del error generado. Por ejemplo:
begin
# Error...
rescue
# intento de recuperación...
retry # tratar de nuevo
ensure
# Este código es siempre ejecutado
end
Ejemplos:
def raise_exception
puts 'Antes de raise.'
raise 'Ocurrio un error'
puts 'Después de raise'
end
raise_exception
def raise_y_rescue
begin
puts 'Antes de raise.'
raise 'Ocurrio un error.'
puts 'Después de raise.'
rescue
puts 'Siendo rescatado.'
end
puts 'Despues del bloque begin - end.'
end
raise_y_rescue

- 371 -
begin
# ...
rescue UnaExepcion
# ...
rescue OtroTipoDeExepcion
# ...
else
# Otras exceciones
end
begin
raise "Probando excepciones."
rescue Exception => e
puts "Salida:"
puts e.message
puts e.backtrace.inspect
puts "fin salida."
end
x = a/b rescue puts("Division entre cero!")
Jerarquía de Excepciones
Las excepciones en Ruby dependen de una jerarquía de herencia la cual tiene

como superclase a Exception [30]:
* Exception
o NoMemoryError
o ScriptError
+ LoadError
+ NotImplementedError

- 372 -
+ SyntaxError
o SignalException
+ Interrupt
o StandardError (default for rescue)
+ ArgumentError
+ IOError
# EOFError
+ IndexError
+ LocalJumpError
+ NameError
# NoMethodError
+ RangeError
# FloatDomainError
+ RegexpError
+ RuntimeError (default for raise)
+ SecurityError
+ SystemCallError
# Errno::*
+ SystemStackError
+ ThreadError
+ TypeError
+ ZeroDivisionError
o SystemExit
o fatal
De igual forma es posible derivar algunas de las clases de la jerarquñia de

excepciones para crear una excepción más especializada.
Catch & Throw
Es posible en Ruby usar también los clásicos catch & throw los cuales son usados
comúnmente cuando es necesario saltar de un punto de anidamiento más
profundo [12].

- 373 -
Sintaxis:
catch (:label) do
#...
end
throw :label #salta atrás hasta el catch correspondiente y

ejecuta el bloque
Ejemplo:
def pregunta pr
print pr
res = readline.chomp
throw :salida_solicitada if res == "!"
res
end
catch :salida_solicitada do
nombre = pregunta "Nombre: "
edad = pregunta "Edad: "
sexo = pregunta "Sexo: "
# ...
end
throw puede ser usado en múltiples niveles de anidamiento. Es importante usar el

manejo de excepciones realmente para comportamientos que no vayan con el
flujo normal del programa.

- 374 -
Introducción a Multihilos en Java
Aunque de manera estricta todos los programas de Java manejan más de un

hilo, de vista al usuario los programas por lo general son de un único hilo de
control (flujo único). Sin embargo pueden contar con varios hilos de control (flujo
múltiple).
Existen dos formas de implementar hilos en un programa de Java. La forma

más común es mediante herencia, extendiendo la clase Thread.
Programas de flujo múltiple
Los programas en Java implementan un flujo único de manera implícita. Sin

embargo, Java posibilita la creación y control de hilos explícitamente. La
utilización de hilos en Java, permite una enorme flexibilidad a los programadores
a la hora de plantearse el desarrollo de aplicaciones. La simplicidad para crear,
configurar y ejecutar hilos, permite que se puedan implementar muy poderosas y
portables aplicaciones y/o applets.
Las aplicaciones multihilos utilizan muchos contextos de ejecución para

cumplir su trabajo. Hacen uso del hecho de que muchas tareas contienen
subtareas distintas e independientes. Se puede utilizar un hilo para cada subtarea.
Mientras que los programas de flujo único pueden realizar su tarea

ejecutando las subtareas secuencialmente, un programa multihilos permite que
cada hilo comience y termine tan pronto como sea posible. Este comportamiento
presenta una mejor respuesta a las necesidades de muchas aplicaciones.
Veamos un ejemplo de un pequeño programa multihilos en Java.

- 375 -
Ejemplo:
class MiHilo extends Thread {
public MiHilo (String nombre) {

super (nombre);
}
public void run() {

for( int i=0; i<4; i++){
System.out.println( getName() + " " + i );
try {
sleep(400);
} catch( InterruptedException e) { }
}
}
}
public class MultiHilo {

public static void main(String arrg[]) {
MiHilo mascar = new MiHilo("Mascando");
MiHilo silbar = new MiHilo("Silbar");
mascar.start();
silbar.start();
}
}
Este pequeño ejemplo ejecuta dos hilos. Uno llamado mascar y otro silbar.
Por lo que el programa es capaz de "mascar" y "silbar" al mismo tiempo, aunque
como ya sabemos, en una computadora de un solo procesador tendrá que dejar de
mascar para poder silbar, y viceversa.

- 376 -
Estados de un hilo
Cada hilo de ejecución en Java, es un objeto que puede estar en diferentes

estados.
Ejecutándose Esperando Durmiendo Bloqueado
entrando a
no-ejecutable
finalizando
Muerto
Podemos apreciar que cuando un hilo es creado, no quiere decir que se

encuentre corriendo, sino que esto sucede cuando es invocado el método start()
del objeto. Es hasta entonces que se encuentra en un estado de "Listo para
ejecutarse".
Cuando un hilo está ejecutándose pueden pasar varias cosas con ese hilo en
particular. El método start() llama en forma automática al método run(). Este
método contiene el código principal del hilo, algo así como un método main para
un programa principal.
Un hilo que está en ejecución puede pasar a un estado de muerto si termina

de ejecutar al método run( ).
El estado de "no-ejecutable". Se llega a este estado cuando el hilo no esta

"en ejecución", debido a una llamada del método sleep(), wait() o porque se está
realizando un proceso de entrada/salida que tarda cierto tiempo en ejecutarse.

- 377 -
Existen los métodos stop(), suspend() y resume(), pero estos han sido
desaprobados en la versión 2 de Java debido a que se consideran potencialmente
peligrosos para la ejecución de los programas concurrentes.46
Veamos ahora un diagrama que muestra de manera más completa los

estados en los que puede estar un hilo.
nacido
start
listo
despachar
expiración (asignar un
de cuanto procesador)
notify
Finalizada e/s
notifyAll en ejecución
wait
sleep Emitir
solicitud de e/s
en espera dormido bloqueado
Fin de
ejecución
expira el intervalo muerto

de sleep
46
El que sean desaprobados no quiere decir que ya no puedan ser usados. Se conservan por compatibilidad
hacia atrás con el lenguaje, pero se ha visto que no es recomendable su uso. En algunos ejemplos pueden
aparecer estas instrucciones por simplicidad.
- 378 -
La clase Thread
El programa de ejemplo que se vio antes, corresponde a la forma de

implementación más común de un hilo: mediante la extensión de la clase Thread.
Por lo que se pudo apreciar, la sintaxis para la creación de un hilo seria:
class MiHilo extends Thread {
public void run() {
. . .
}
}
Esta técnica, extiende a la clase Thread, y redefine el método run(), el cual

debe contener un implementación propia, de acuerdo a lo que se quiera que
realice el hilo.
Vamos a mencionar ahora los principales métodos de la clase.47
Thread(String Constructor de la clase Thread, recibe una

nombreThread) cadena para el nombre del hilo.
Thread( ) Constructor sin parámetros. Crea de
manera automática nombres para los hilos.
Llamados Thread1, Thread2, etc.
start() Inicia la ejecución de un hilo. Invoca al
método run().
run() Este método se redefine para controlar la
ejecución del hilo.
sleep( tiempo ) Causa que el hilo se "duerma" un tiempo
determinado. Un hilo dormido no compite
por el procesador.
interrupt( ) Interrumpe la ejecución de un hilo.
interrupted() Método estático que devuelve verdadero si
47
Para las características completas ver la documentación: Java Platform API Specification

- 379 -
el hilo actual ha sido interrumpido.

isInterrupted() Método no estático que verifica si un hilo
ha sido interrumpido.
join( ) Espera a que un hilo específico muera
antes de continuar. Está sobrecargado para
recibir un tiempo límite de espera como
parámetro.
yield( ) El hilo cede la ejecución a otros hilos.
Comportamiento de los hilos
La implementación real de los hilos puede variar un poco de una plataforma

a otra. Algunos sistemas como Windows, los hilos funcionan por rebanadas de
tiempo y otros como muchas versiones de Unix no tienen esta característica.
En los sistemas que se manejan rebanadas de tiempo, los hilos de igual

prioridad se reparten el tiempo de ejecución en partes iguales. En los sistemas que
no tienen rebanadas de tiempo, un hilo se ejecuta hasta que cede el control
voluntariamente, se lo quita un hilo de mayor prioridad, o termina su ejecución.
Bajo este último esquema, es importante que un hilo delegue el control cada
determinado tiempo a hilos de igual prioridad. Para esto sirve poner a dormir el
hilo con sleep(), o ceder el control con el método yield(). Un método que tiene
estas consideraciones se conoce como hilo compartido, el caso contrario se
conoce como hilo egoísta.
Tener en cuenta que el método yield() cede el control a hilos de la misma

prioridad. Esto es útil en plataformas que no cuenten con rebanadas de tiempo,
pero no tiene sentido en sistemas que si cuentan con esta técnica.48
Veamos una clase que implementa un hilo y cede el control a otros hilos.
48
Sin embargo debería siempre considerarse el uso de yield() si se piensa en sistemas multiplataformas.
- 380 -
Ejemplo:
class HiloEterno extends Thread {
public HiloEterno (String nombre) {

super (nombre);
}
public void run()

{
int i=0;
while (true) // Iterar para siempre

{
System.out.println(getName() + " " +"Ciclo " + i++);
if (i%100==0)
yield(); // Ceder el procesador a otros hilos
}
}
}
public class MultiHilo2 {

public static void main(String arrg[]) {
HiloEterno infinito = new HiloEterno("Al infinito");
HiloEterno masAlla = new HiloEterno("y mas alla");
infinito.start();
masAlla.start();
}
}

- 381 -

- 382 -
Interfaz Gráfica AWT
La independencia de la plataforma de Java se vuelve a poner de manifiesto a

la hora de crear las interfaces gráficas con el usuario. En otros lenguajes, si se
quiere hacer un programa que corra en distintas plataformas, una de las partes
más críticas es precisamente el de la interfaz con el usuario.
En Java, el paquete Abstract Windowing Toolkit, mejor conocido como

AWT, es el que proporciona las clases para el manejo de la interfaz, las cuales
son independientes de la plataforma. Así, es posible definir ventanas, cuadros de
diálogo, botones o el elemento gráfico que se necesite, y es representado en cada
sistema como si se tratara de un elemento nativo.49
Como el AWT se trata de un paquete que no esta incluido implícitamente en

el lenguaje, es necesario indicarle al compilador cual es su ubicación:
import java.awt.*;
Dentro del AWT existen un gran número de clases con capacidades gráficas,
componentes y elementos para el manejo de eventos. La información completa de
cada clase se puede consultar en la documentación del jdk de Java.
Clases de ventana
Para crear una aplicación gráfica, es necesario crear un objeto de tipo

ventana. El AWT ofrece una clase Window que define a un objeto genérico
ventana. Esta clase tiene como subclases principales a la clase Frame y la clase
Dialog.
La clase Window implementa los métodos generales de una ventana, pero

carece de borde o de barra de menús en el momento de su creación.
49
Existe también conjunto de clases llamadas Swing, que se prevé que sustituyan al AWT ya que permiten
manipular y respetar el look and feel de cada ambiente gráfico.
- 383 -
Clase Frame
Esta clase es usada comúnmente para proporcionar la ventana principal de

una aplicación. Es una subclase de Window y además implementa la interfaz
MenuContainer, por lo que es capaz de trabajar con objetos de menú de la clase
MenuBar.
La clase Frame añade métodos de acceso para la obtención y

establecimiento del título de la ventana, la imagen del icono y la barra de menús,
entre otros. Además define dos constructores, uno sin parámetros y otro que
recibe una cadena para determinar el título de la ventana.
Clase Dialog
Esta también es una subclase de Window, y es utilizada para implementar

ventanas de cuadro de diálogo. Los cuadros de dialogo pueden ser modales o no
modales. Un cuadro de diálogo modal no regresa el control a la aplicación hasta
que no se cierra el cuadro de diálogo.
Clase Filedialog
Este es un tipo especial de cuadro de diálogo, y es usada para crear cuadros

de diálogo de selección de archivos para entrada o salida. A través de las
constantes LOAD o SAVE en un parámetro del constructor se puede ajustar el
comportamiento del cuadro de diálogo. Ofrece métodos de acceso al nombre del
archivo y su ruta, y la posibilidad de especificar un filtro para la vista de archivos.
Ejemplo:
//clase HolaVentanas
import java.awt.*;
import java.awt.event.*;

- 384 -
public class HolaVentanas extends Frame {

public static void main(String args[]){
HolaVentanas app = new HolaVentanas();
}
public HolaVentanas() {
super("Hola Ventanas!"); //asigna titulo a la ventana
setSize(200,200); //define el tamaÒo de la ventana
addWindowListener(new
HolaVentanas.WindowEventHandler()); //asocia a los eventos de
la ventana
setVisible(true); //muestra la ventana en pantalla
public void paint(Graphics g) {

g.drawString("Hola Ventanas!",50,90);
}
class WindowEventHandler extends WindowAdapter {

public void windowClosing(WindowEvent e){ //asocia
al evento de cerrar ventana
System.exit(0); // con
la salida del programa
}
}
}
Esta clase extiende a la clase Frame, y de esta forma hereda la funcionalidad

básica de una ventana de aplicación.
Componentes gráficos
Veamos ahora una aplicación más grande y funcional, que incluya algunos
componentes gráficos básicos como los campos de texto (TextField), etiquetes
(Label) y botones (Button), los cuales son sólo algunos de los elementos gráficos
proporcionados por Java.
- 385 -
Ejemplo:
//Clase CalAhorro
import java.awt.*;
public class CalAhorro extends Frame {
TextField campo_interes = new TextField("",15);

TextField campo_anios = new TextField("",15);
TextField campo_pago = new TextField("",15);
Label cant_total = new Label("", Label.LEFT);
Button boton = new Button("Calcular");
// Metodo para calcular el ahorro total

public double calc_ahorro(double interes, double cantidad,
int anios)
{
int num_pagos = anios * 12; // numero de pagos
double tasa_mensual = 1.0 + interes / 1200.0; // tasa +
1.0
double total = 0;
// Calcular el ahorro total

for (int i = 0; i < num_pagos; i++)
{
total += cantidad;
total *= tasa_mensual;
}
// Regresar el ahorro total mas los intereses

return(total);
}
public CalAhorro(String titulo)

{
super(titulo);
setLayout(new GridLayout(5,2,3,2));
// métodos add añaden los elementos gráficos al objeto
Layout de la ventana

- 386 -
add(new Label("Tasa de interés anual %:",

Label.RIGHT));
add(campo_interes);
add(new Label("Número de Años:", Label.RIGHT));
add(campo_anios);
add(new Label("Contribución Mensual $:", Label.RIGHT));
add(campo_pago);
add(new Label("Ahorro Total $:", Label.RIGHT));
add(cant_total);
add(new Label());
add(boton);
}
public static void main(String args[])

{
CalAhorro aplicacion = new CalAhorro("CalAhorro");
aplicacion.pack(); //ajusta la ventana al tamaño mínimo
en que se muestren todos los componentes gráficos
aplicacion.setVisible(true); //muestra la ventana
}
public boolean action(Event evt, Object arg)

{
double interes, cant_mensual, ahorro_total;
int anios;
if (evt.target == boton)
{ // Obtener los datos del usuario
interes =
Double.valueOf(campo_interes.getText()).doubleValue();
cant_mensual = Double.valueOf(
campo_pago.getText()).doubleValue();
anios=Integer.valueOf(campo_anios.getText()).intValue();
// Calcular el ahorro total

ahorro_total = calc_ahorro(interes, cant_mensual,
anios);
// Poner el resultado en la etiqueta

- 387 -
cant_total.setText(String.valueOf(ahorro_total));
return true; // evento procesado
}
return false; // evento no procesado
}
public boolean handleEvent(Event evt)

{
if (evt.id == Event.WINDOW_DESTROY)
System.exit(0); // terminar la aplicación
50
return super.handleEvent(evt);
}
}
Esta aplicación muestra el uso de los componentes gráficos básicos, cada

uno de ellos cuenta con un conjunto de miembros para su manipulación y además
estos componentes son colocados sobre un objeto de tipo Layout, como se aprecia
en la instrucción:
setLayout(new GridLayout(5,2,3,2));
Veamos ahora otro ejemplo, el cual a través de un objeto Choice permite la

selección de los diferentes tipos de cursores que son definidos en Frame como
constantes estáticas. El cambio de cursor se logra a través del método:
void setCursor(int tipoApuntador)
Ejemplo:
//clase Apuntador
import java.awt.*;
public class Apuntador extends Frame {
String elementos[] = {"DEFAULT","CROSSHAIR","TEXT","WAIT",
50
El método handleEvent pertenece al sistema antiguo de manejo de eventos, pero aún es soportado.
- 388 -
"SW_RESIZE", "SE_RESIZE","NW_RESIZE","NW_RESIZE",
"NE_RESIZE", "N_RESIZE","S_RESIZE","W_RESIZE","E_RESIZE",
"HAND", "MOVE"};
int apuntadores[]={ Frame.DEFAULT_CURSOR,

Frame.CROSSHAIR_CURSOR,
Frame.TEXT_CURSOR, Frame.WAIT_CURSOR,
Frame.SW_RESIZE_CURSOR,
Frame.SE_RESIZE_CURSOR,
Frame.NW_RESIZE_CURSOR,
Frame.NW_RESIZE_CURSOR,
Frame.NE_RESIZE_CURSOR,
Frame.N_RESIZE_CURSOR,
Frame.S_RESIZE_CURSOR,
Frame.W_RESIZE_CURSOR,
Frame.E_RESIZE_CURSOR, Frame.HAND_CURSOR,
Frame.MOVE_CURSOR };
Choice menu = new Choice();
public Apuntador(String titulo)

{
super(titulo);
for (int i = 0; i < elementos.length; i++)

menu.addItem(elementos[i]);
add("North", menu); //añade objeto en la parte

superior de la ventana
}
public static void main(String args[])

{
Apuntador aplicacion = new Apuntador("Apuntadores");
aplicacion.setSize (250, 150);
aplicacion.setVisible(true);
}

{

- 389 -
if (evt.target instanceof Choice)

{
setCursor(apuntadores[menu.getSelectedIndex()]);
}
}
public boolean handleEvent(Event evt)

{
System.exit(0); // terminar la aplicacion
}
}
Aplicaciones con menús
Es común que una aplicación gráfica necesite de menús como una forma de
ofrecer distintas posibilidades de operación del programa de acuerdo a la solicitud
del usuario. Para esto se incluyen clases que permiten el manejo de menús.
Clase MenuBar
Esta clase permite la creación de una instancia barra de menús, la cual se

asocia al objeto de tipo Frame a través del método setMenuBar(). La barra de
menú es donde se colocarán posteriormente cada una de las opciones principales
del menú de la aplicación. Un ejemplo de la creación de una barra de menú se
presenta a continuación:
MenuBar barra_menu = new MenuBar();

f.setMenuBar(barra_menu);
Clase Menu

- 390 -
Una vez que se tiene la barra de menú, es necesario crear objetos de la clase
Menu, uno por cada opción de menú deseada. Posteriormente estos objetos se
asocian a la barra de menú:
Menu menu_archivo = new Menu("Archivo");

Menu menu_editar = new Menu("Editar");
menubar.add(menu_archivo);
menubar.add(menu_editar);
Clase MenuItem
Cada menú tiene comúnmente un conjunto de opciones. Estas pueden

crearse asociando instancias de la clase MenuItem, de la siguiente forma:
menu_archivo.add(new MenuItem("Abrir"));
menu_archivo.add(new MenuItem("Guardar"));
menu_editar.add(new MenuItem("Cortar"));
Aunque el método add() de los objetos de la clase Menu esta sobrecargado

para aceptar una cadena e implícitamente se creara un objeto MenuItem
internamente, por lo que el segmento de código anterior puede ser escrito de la
siguiente forma:
menu_archivo.add("Abrir");
menu_archivo.add("Guardar");
menu_editar.add("Cortar");
Ejemplo:
// clase PruebaMenu
import java.awt.*;
public class PruebaMenu extends Frame {

//false en lugar de true agrega la opción en modo desactivado
Menu archivo = new Menu("Archivo", true);
Menu editar = new Menu("Editar", true);
- 391 -
public PruebaMenu(String titulo) {

super(titulo);
setMenuBar(barra_menu);
barra_menu.add(archivo);
barra_menu.add(editar);
archivo.add("Nuevo");
archivo.add("Abrir");
archivo.add("Guardar");
editar.add("Cortar");
editar.add("Copiar");
editar.add("Pegar");
}

PruebaMenu aplicacion = new PruebaMenu("prueba_menu");
aplicacion.setSize(250, 125);
}
public boolean handleEvent(Event evt) {

System.exit(0);
}

{
if (evt.target instanceof MenuItem) {
if (arg.equals("Abrir"))
System.out.println("Opción Archivo / Abrir");
else if(arg.equals("Guardar"))
System.out.println("Opción Archivo / Guardar");
// Repetir la comparación para las demás opciones

}
}
}

- 392 -
Ejemplo de la clase Filedialog:

//clase PruebaFileDialog
import java.awt.*;
public class PruebaFileDialog extends Frame {

Menu menu_archivo = new Menu("Archivo", true);
public PruebaFileDialog(String titulo) {

super(titulo);
setMenuBar(barra_menu);
barra_menu.add(menu_archivo);
menu_archivo.add("Abrir");
}

PruebaFileDialog aplicacion = new
PruebaFileDialog("prueba FileDialog");
aplicacion.setSize(200, 100);
}
public boolean handleEvent(Event evt) {

System.exit(0);
}
public boolean action(Event evt, Object arg) {

if (evt.target instanceof MenuItem) {
if (arg.equals("Abrir")) {
FileDialog fd = new FileDialog(this, "Abrir
Archivo");
fd.setVisible(true);
System.out.println("Directorio:" +
fd.getDirectory());
System.out.println("Archivo: " + fd.getFile());
}
return true;

- 393 -
}
return false;
}
}
Manejo de Eventos
Introducción
El diseño de interfaces gráficas obliga a tomar en cuenta el manejo de

eventos. Existe un modelo de manejo de eventos que ha sido desaprobado desde
la versión 1.1 del jdk.
El mecanismo de eventos de la versión 1.0 era considerado rudimentario, y

estaba inspirado de la estructura de manejo de eventos de la ToolBox de
Macintosh. La solución sirve para programas pequeños, pero en aplicaciones más
complejos aparecen algunas deficiencias:
• El sistema de subclasificación de componentes ha dado lugar a una

creación excesiva de clases derivadas de los componentes estándar
únicamente por la necesidad de manejar los eventos, cuando sólo debería
utilizarse la herencia para una apariencia gráfica específica o un
comportamiento funcional distinto.
• No se permite una separación clara entre la interfaz de usuario y los

tratamientos funcionales que tiene asociados, por lo que los componentes
creados no son reutilizables.
• Utilizar un mismo método para manejar todos los eventos de tipos

diferentes implica numerosos problemas de depuración.
• No se pueden filtrar los eventos. Estos se distribuyen sistemáticamente a

los componentes, tanto si los manejaban o no. Esto implica una reducción
notable de velocidad cuando el número de eventos era muy grande.
- 394 -
• Los métodos action() mandan una cadena de caracteres para indicar el

título del componente fuente del evento o la línea seleccionada,
ocasionando algunos problemas de codificación poco confiable debido a
las comparaciones de cadenas de caracteres.
Modelo de manejo de eventos actual
El principio esencial del nuevo modelo se basa en la delegación. Los

componentes delegan el manejo de los eventos de usuario a una clase externa.
Este modelo responde a las críticas del anterior:
• Ya no es necesario crear una clase por componente.
• Cada componente de la interfaz sólo transmitirá a la aplicación los eventos

que espera. Se efectúa de modo predeterminado un filtrado inteligente.
• Es posible separar claramente los tratamientos funcionales de los eventos de

la interfaz de usuario, permitiendo así una verdadera reutilización de los
componentes gráficos por un lado, y de las clases funcionales por otro lado.
java.util.EventObject
<<interfaz>>
java.util.EventListener
Evento
Origen del Delegado para

Origen
evento el evento
del
El funcionamiento del nuevo modelo es un poco más complejo, de acuerdo

al esquema de la figura anterior:

- 395 -
• Los eventos son objetos que derivan de la clase java.util.EventObject.

Existe ahora una jerarquía de eventos (ver figura 3).
• Un origen de eventos, en general un componente gráfico derivado de

Component, emite un evento hacia un delegado capaz de tratarlo.
• El delegado indica que está interesado por un evento en particular

implementando una o más interfaces específicas derivadas de
java.util.EventListener.
• Para enlazar al origen del evento y al delegado, el delegado debe

previamente estar registrado en el origen. Por lo que el origen debe definir
métodos de registro de los delegados de acuerdo a una de las dos siguientes
formas:
public <TipoEvento>Listener set<TipoEvento>Listener

(<TipoEvento>Listener miDelegado)
public <TipoEvento>Listener add<TipoEvento>Listener

(<TipoEvento>Listener miDelegado)
donde la primera opción es utilizada para una difusión hacia un solo

delegado51; mientras que la segunda permite la difusión hacia múltiples
delegados52.
El tipo de evento correspondería a una clase derivada de

java.util.EventObject, como eventos de mouse (MouseListener) o eventos de
acción (ActionListener). Una lista completa de la jerarquía de eventos puede verse
en la documentación de Java.
51
También llamada difusión simple.
52
Difusión múltiple.
- 396 -
Veamos un programa que únicamente contiene un botón, el cual al

presionarse cierra la aplicación.
Ejemplo:
//programa EjemploEvento1
import java.awt.*;
public class EjemploEvento1 extends Frame {
public EjemploEvento1() {
Button miBoton= new Button("boton");
/* El metodo siguiente registra al delegado en el boton

tras haberlo creado. Todos los componentes estandar del AWT
permiten la difusión múltiple, es por esto que solo existen
metodos de tipo add<Tipo>Listener */
miBoton.addActionListener( new MiDelegado() );
add(miBoton);
}

EjemploEvento1 f= new EjemploEvento1();
f.pack();
f.setVisible(true); //puede ser usado en lugar de show()
}
}
//esta es la clase delegada, que gestiona los eventos sobre el

raton
class MiDelegado implements ActionListener {

- 397 -
public void actionPerformed( ActionEvent e ){

System.exit(0);
}
}
Esta clase MiDelegado, podría convertirse en una clase anónima que

estuviera definida dentro de la clase EjemploEvento1.
Ejemplo:
import java.awt.*;
public class EjemploEvento2 extends Frame {
public EjemploEvento2() {
Button miBoton= new Button("boton");
miBoton.addActionListener(
// se crea una clase anonima que implementa
ActionListener
new ActionListener () {
public void actionPerformed( ActionEvent e ){

System.exit(0);
}
}
);
add(miBoton);
}

EjemploEvento2 f= new EjemploEvento2();
f.pack();
f.setVisible(true);

- 398 -
}
}
Esta clase también generará un archivo class, pero se le asignará después del
nombre de la clase un número que la identifique.
Adaptadores
En aplicaciones más grandes, es necesario añadir una clase intermedia, que

servirá de intermediario entre el objeto fuente y el delegado. Esto permite separar
aún mejor la interfaz del usuario del código de manejo de eventos, permitiendo un
mayor grado de reuso.
Además, el adaptador permite efectuar operaciones complementarias sobre

los eventos.
Un adaptador tiene como función mínima implementar la interfaz o

interfaces de los eventos que quiere vigilar.
Veamos ahora otro programa similar al presentado inicialmente, pero

contiene además un botón para maximizar la ventana. Se añade una clase única
adaptador que permite desviar los mensajes hacia el delegado.
Ejemplo:
import java.awt.*;
public class EjemploEvento3 extends Frame{
public EjemploEvento3(){
// se crea un delgado para esta interfaz

MiDelegado unDelegado = new MiDelegado();

- 399 -
// se crea el boton salir

Button miBotonSalir = new Button("Salir");
// se le asigna un adaptador
miBotonSalir.addActionListener(new
MiAdaptador(MiAdaptador.SALIR, unDelegado));
// se hace lo mismo con el boton maximizar

Button miBotonMaximizar = new Button("Maximizar");
miBotonMaximizar.addActionListener(new
MiAdaptador(MiAdaptador.MAXIMIZA, unDelegado));
// se añaden los botones en la interfaz

setLayout(new FlowLayout());
add(miBotonSalir);
add(miBotonMaximizar);
// el metodo principal no cambia

EjemploEvento3 f=new EjemploEvento3();
f.pack();
f.setVisible(true);
}
}
//el delegado posee dos metodos funcionales

class MiDelegado {
public void salirApl(){

System.exit(0);
}
public void maximizar(Frame f){
f.setSize(f.getToolkit().getScreenSize());
}
}

- 400 -
// el adaptador efectua la desviacion

class MiAdaptador implements ActionListener {
public static final int SALIR = 1;
public static final int MAXIMIZA = 2;
protected int tipoAccion;// la accion afecta al
adaptador
protected MiDelegado elDelegado;// el delegado que
tratara la acion
public MiAdaptador(int unTipoAccion,MiDelegado

unDelegado) {
tipoAccion = unTipoAccion;
elDelegado = unDelegado;
}
public void actionPerformed(ActionEvent e){
// se recupera la ventana fuente del evento: se sube

por la cadena
// de componentes, hasta encontrar una instancia de la
clase Window
Object unComponente = e.getSource();
do{
unComponente = ( (Component)
unComponente).getParent();
}while (!(unComponente instanceof Window));
Window ventanaPrincipal = (Window) unComponente;
switch (tipoAccion){
case SALIR:
// se llama el metodo salirApl del delegado
elDelegado.salirApl();
break;
case MAXIMIZA:
// se llama al metodo maximizar pasando el
Frame que contiene el componente sobre el que se ha producido
el evento.

- 401 -
elDelegado.maximizar((Frame)
ventanaPrincipal);
break;
}
}
}
El ejemplo anterior, no parece brindar ventajas en relación al código o ser

más compresible que el manejo de eventos del modelo anterior; sin embargo, es
más robusto en aplicaciones grandes. Pudiera además tenerse una mejor
distribución del código, identificando claramente la parte de la interfaz con el
usuario del código de resolución de eventos.
Ejemplo:
//Programa EjemploEvento4.java
import java.awt.*;
// la clase principal es la aplicacion, y sirve de delegado.

public class EjemploEvento4 {
// contiene los dos metodos funcionales

public void salirApl() {
System.exit(0);
}
public void maximizar(Frame f){

f.setSize( f.getToolkit().getScreenSize() );
}
// se instancia la aplicacion
EjemploEvento4 miApl = new EjemploEvento4();
// se crea el objeto de interfaz con el usuario y se

enlaza con la aplicacion
InterfazUsuario miIU = new InterfazUsuario(miApl);

- 402 -
}
}
// esta clase construye la interfaz de la aplicacion

class InterfazUsuario {
// su constructor posee como parametro la aplicacion a

la que esta enlazada
public InterfazUsuario(EjemploEvento4 unaApl) {
Frame miFrame = new Frame("Aplicacion");
miFrame.setLayout(new FlowLayout());
// se crea el boton Salir

Button miBotonSalir = new Button("Salir");
// se le asigna un adaptador
miBotonSalir.addActionListener(new
MiAdaptador(MiAdaptador.SALIR, unaApl) );
// se hace igual con el boton maximizar

Button miBotonMaximizar=new Button("Maximizar");
miBotonMaximizar.addActionListener(new
MiAdaptador(MiAdaptador.MAXIMIZA, unaApl) );
// se añaden los botones en la interfaz y se hace

la ventana visible
miFrame.add(miBotonSalir);
miFrame.add(miBotonMaximizar);
miFrame.pack();
miFrame.setVisible(true);
}
}
// el adaptador efectua la desviacion

class MiAdaptador implements ActionListener {
static final int SALIR = 1;

static final int MAXIMIZA = 2;
protected int tipoAccion; // la accion asignada al
adaptador

- 403 -
protected EjemploEvento4 IApl; // el delegado que tratara

la accion
public MiAdaptador(int unTipoAccion, EjemploEvento4

unaApl) {
tipoAccion = unTipoAccion;
IApl = unaApl;
}
public void actionPerformed(ActionEvent e) {
// se recupera la ventana fuente del evento: se sube

por la cadena
// de componentes, hasta encontrar una instancia de
la clase Window
Object unComponente = e.getSource();
do {
unComponente = ( (Component)unComponente
).getParent();
} while (!(unComponente instanceof Window));
Window ventanaPrincipal = (Window) unComponente;
switch (tipoAccion) {
case SALIR:
// se llama al metodo salirApl del delegado

IApl.salirApl();
break;
case MAXIMIZA:
// se llama al metodo maximizar pasando el
Frame
// que contiene el componente sobre el que
se ha producido el evento
IApl.maximizar((Frame)ventanaPrincipal);
break;
}
}
}

- 404 -

- 405 -
Se presenta una gráfica mostrando la organización de paquetes y las

jerarquías de los eventos y de Listeners:

- 406 -
Otras tecnologías Java
Java cuenta con otras tecnologías que apoyan la construcción de sistemas

distribuidos, y el objetivo es que para sistemas grandes se puedan combinar
dependiendo de las necesidades de cada una de las áreas. Algunas de estas
tecnologías ya vienen soportadas por la edición estándar de Java (JAVA SME),
recordemos que existen tres ediciones del lenguaje:
• Java SE. Java Platform Standard Edition, es la versión más común y popular
de Java. Contiene los servicios estándar para applets y aplicaciones, entrada
salida, prestaciones para desarrollo de la interfaz gráfica con el usuario, etc. La
mayor parte de lo visto sobre Java se encuentra en esta edición.
• Java ME. Java Platform Micro Edition, es la plataforma de desarrollo para

dispositivos con soporte para Java, como aparatos eléctricos y dispositivos
móviles (Palm Pilot, celulares, pagers). Se trata de un subconjunto muy
restringido del lenguaje Java y clases, buscando mejorar el rendimiento y
reducir los requerimientos de sus programas debido a las restricciones de estos
dispositivos.
• Java EE. Java Platform Enterprise Edition, está basada en la versión estándar,
pero añade un conjunto de API's que permiten el desarrollo de clases de tipo
enterprise, dando mayor soporte a las aplicaciones servidor. Esta edición de
Java fue liberada apenas en diciembre de 1999, aunque algunas de las
tecnologías ya se encontraban disponibles desde antes.
En la figura se puede apreciar mejor como se ubican y complementan cada una

de las ediciones de Java:

- 407 -
Ediciones de la plataforma de Java.
Principales tecnologías de Java EE.
Se hace una breve mención de las tecnologías con que cuenta Java EE, de
forma que puedan ser tomadas en cuenta en la construcción de aplicaciones Java.
• EJB. Enterprise JavaBeans, es la arquitectura para desarrollo de componentes

del lado del servidor. Ofrece los estándares para crear componentes estándar,
construcción de interfaces entre distribuidores y clientes de software. De
alguna forma es la punta de lanza de la JAVA EE, y se apoya en otras API's de
esta edición.
• CORBA. CORBA es parte integral de JAVA EE, a través de tres productos de

Java: RMI-IIOP, Java IDL, y Java Transaction Service.
• JNDI. Java Naming and Directory Interface, provee servicios de nombre y

directorios para poder ser integrados en applet y aplicaciones de
Java. Se trata de un producto 100% Java y es la solución de Sun
de productos como X.500 de la ISO y NDS (Servicio de

- 408 -
Directorios Netware) de Novell. Ofrece capacidades de búsqueda de

componentes y recursos entre redes heterogéneas.
• JMS. Java Message Service, permite la comunicación asíncrona de objetos

distribuidos. JMS soporta los estilos de mensaje de publicación / suscripción o
punto a punto.
• Servlets. Los servlets son la contraparte de los applets, mientras que estos
últimos corren en el cliente, los servlets son pequeñas aplicaciones que se
ejecutan del lado del servidor. Esto permite extender la funcionalidad de los
servidores de web ofreciendo programas basados en componentes e
independientes de la plataforma.
• JSP. Java Server Pages, es la respuesta de Java a las páginas ASP. Los JSP
son scripts compilados dentro de servlets53, pero con la diferencia de que los
JSP scripts no tienen código Java puro.
• XML. Extensible Markup Language. Este es un estándar para estructurar el

contenido de documentos electrónicos, y está tomando bastante
fuerza en el mercado, y se supone que a la larga sustituya a
HTML. Java EE ofrece soporte para XML; además de que lo
puede usar en JSP's para darle formato a las páginas generadas
dinámicamente, los EJB usa XML para describir componentes y JMS apoya el
envío de datos asíncronos XML.
• JDBC. La versión 2 de JDBC es incluida en parte en la edición estándar, como

el soporte para SQL 3 (SQL 1999). Sin embargo, algunas características se
incluyen como una extensión a la edición estándar: soporte a JNDI, manejo de
transacciones distribuidas y manejo de JavaBeans.
53
De hecho, JSP es una extensión de Java Servlets API.
- 409 -
• Connector. Se trata de una arquitectura para ofrecer soluciones Java de

conectividad entre múltiples servidores de aplicación y sistemas de
información empresariales existentes.
• Transaction. Java EE simplifica el manejo de transacciones para aplicaciones

distribuidas, está constituido por dos especificaciones: JTA, Java Transaction
API, y JTS, Java Transaction Service. JTA permite que una aplicación y un
servidor de aplicaciones manejen transacciones. JTS especifica la
implementación de un administrador de transacciones con soporte JTA.
Otras tecnologías (no necesariamente Java)
Tecnología Google
• GWT. El Google Web Kit es un kit de desarrollo para apñicaciones web

tipo AJAX, donde el programador desarrolla en Java y es posible generar
código JavaScript.
• Google App Engine. Es un motor de aplicaciones de Google que permite
desarrollar aplicaciones web y ejecutarlas en la
infraestructura de Google. Por el momento el desarrollo es
en el lenguaje Python pero se esta tranajando en
soporte para lenguajes como Java y Ruby.
• Gears. Es un proyecto Open Source lidereado por Google que permite

almacenar información localmente habilitando la posibilidad de manejar
aplicaciones web fuera de línea. También permite ejecutar JavaScript en el
fondo (workerpools) de manera que se mejora la
ejecución del navegador.
• Android. Es un sistema operativo, middleware y aplicaciones básicas para

dispositivos móviles. El desarrollo se hace en Java con un API específica
para este sistema.

- 410 -
• APIs Diversas de Google. Google distribuye una serie de APIs para poder
desarroolar aplicaciones que utilicen sus recursos. Dentro de éstas se
pueden mencionar: para AJAX, para desarrollo de Gadgets, para manejo
de datos de Google, para YouTube, OpenSocial, manejo de Mapas
Lenguajes dinámicos y frameworks
Algunos de los principales frameworks usados para desarrollo Web:
• Ruby on Rails. Es un framework gratuito para desarrollo

de aplicaciones Web en Ruby.
• Django. Es un framework open source para

desarrollo de aplicaciones web usando Python.
• Grails. Es un framework open source para el

lenguaje Groovy.
• SproutCore. Es un framework open source para desarrllo de aplicaciones

web con JavaScript con el objetivo de crear aplicaciones web que se
comporten y sientan como aplicaciones de escritorio. Usa Ruby para
generar HTML estático y archivos JavaScript. Es usado por Apple
(anunciado en 2008) paragenerar aplicaciones multiplataforma. De hecho,
MobileMe está desarrollado con este framework. Es la opción de Apple
para competir con Flash y Silverlight.

- 411 -
Y más lenguajes
• Groovy. Es un lenguaje orientado a objetos y dinámico,

similar a Python, Ruby, Perl y Smalltalk pero que es
dinámicamente compilado hacia bytecodes de la máquina
virtual de Java.
• JRuby. Es una implementación en Java del intérprete de Ruby. Su alta
integración con Java permite completo acceso en los dos sentidos entre
código Java y Ruby.
• Jython/JPython. Una implementación de Python
en Java. Programas en Jython pueden importar y
usar clases en Java.
• Scala. Es un lenguaje multiparadigma que integra
características de orientado a objetos y programación funcional. Se ejecuta
en la plataforma Java y es compatible con programas en dicho lenguaje.

- 412 -
Referencias
1. Beaton, W. and McAffer, J., Eclipse Rich Client Platform, Eclipse

Foundation, 2006,
http://www.eclipse.org/downloads/download.php?file=/technology/phoenix/
talks/What-is-Eclipse-and-Eclipse-RCP-3.2.6.ppt, Last access: January 2007
2. Weitzenfeld, A., Paradigma Orientado a Objetos, Depto. Academico de
Computacion, ITAM, Mexico, 1994
3. Muller, P., Introduccion a la programacion orientada a objetos empleando
C++, Globewide Network Academy (GNA), 1997, http://uu-
gna.mit.edu:8001/uu-gna/text/cc/Tutorial//tutorial.html
4. Muller, P.-A. Modelado de Objetos con UML. Gestion 2000, España, 1997.
5. Sun Microsystems, The Java Language: An Overview, Sun Microsystems -
Java White Paper, 1997, Last access: April 2002
6. Wegner, P., Classification in Object-oriented Systems. In Proceedings of
1986 SIGPLAN workshop on Object-oriented programming, (New York,
USA, 1986), ACM Press, 173-182.
7. Budd, T. An introduction to object-oriented programming. Addison-Wesley
Pub. Co., Reading, Mass., 1991.
8. Programación Orientada a Objetos en C++, Fundación Arturo Rosenblueth,
México, 1996.
9. Matsumoto, Y. Ruby in a nutshell : a desktop quick reference. O'Reilly,
Sebastopol, CA, 2002.
10. Fulton, H.E. The Ruby way. Addison-Wesley, Upper Saddle River, NJ,
2007.
11. Deitel, H.M. and Deitel, P.J. C++ : how to program. Pearson/Prentice Hall,
Upper Saddle River, NJ, 2005.
12. Thomas, D., Fowler, C. and Hunt, A. Programming Ruby : the pragmatic
programmers' guide. Pragmatic Bookshelf, Raleigh, N.C., 2005.
13. Slagell, M., Ruby User's Guide, 2007,
http://www.rubyist.net/~slagell/ruby/, Last access: March 2008

- 413 -
14. Silver, P.A. THE BOSTON PHOENIX'S GUIDE TO CHEAP EATS:

INEXPENSIVE DINING IN GREATER BOSTON. Harvard Student
Agencies, 1975.
15. Rumbaugh, J. Object-oriented modeling and design. Prentice Hall,
Englewood Cliffs, N.J., 1991.
16. Cruz Matías, I.A. and Fernández-y-Fernández, C.A., UMLGEC ++: Una
Herramienta CASE para la Generación de Código a partir de Diagramas de
Clase UML. In Proceedings of XVI Congreso Nacional y II Congreso
Internacional de Informática y Computación, (Zacatecas, México, 2003),
ANIEI.
17. Cruz Matías, I.A. Herramienta CASE para la generación de código C++ a
partir de diagramas de clase UML, Thesis, Instituto de Electrónica y
Computación, Universidad Tecnológica de la Mixteca, Huajuapan, 2003,
123 pp.
18. Fernández-y-Fernández, C.A. Modelado Visual con UML TEMAS de
Ciencia y Tecnología, 2002, 54-58.
19. Booch, G., Rumbaugh, J. and Jacobson, I. The unified modeling language
user guide. Addison-Wesley, Reading Mass., 1999.
20. Deitel, H.M. and Deitel, P.J. C how to program. Pearson Education, Upper
Saddle River, N.J., 2007.
21. Vandevoorde, D. and Josuttis, N.M. C++ templates : the complete guide.
Addison-Wesley, Boston, MA, 2003.
22. Standard Template Library Programmer's Guide, Silicon Graphics -
Hewlett-Packard Company, 1994, http://www.sgi.com/tech/stl/, Last access:
June 2007
23. Bracha, G., Generics in the Java Programming Language Tutorial, Sun
Microsystems, Mar, 2004, http://java.sun.com/j2se/1.5/pdf/generics-
tutorial.pdf, Last access: June 2007
24. Kreft, K. and Langer, A., Language Features of Java Generics, Fawcette
Technical Publications, 2004,
http://www.ftponline.com/javapro/2004_03/online/jgen_kkreft_03_03_04/d
efault_pf.aspx, Last access: June 2007
25. Turner, K., Catching more errors at compile time with Generic Java, IBM
DeveloerWorks, 2001, http://www.ibm.com/developerworks/library/j-
genjava.html, Last access: June 2007
- 414 -
26. Naftalin, M. and Wadler, P. Java generics and collections. O'Reilly, Beijing
; Sebastopol, CA, 2007.
27. Díaz-Alejo Gómez, J.A., Programación con Java, IES Camp, Valencia,
España, Last access: September 2006
28. Arnold, K., Gosling, J. and Holmes, D. Java (TM) Programming Language,
The. Addison-Wesley Professional, 2005.
29. Sun Microsystems, Programming With Assertions, Sun Microsystems, 2002,
http://java.sun.com/j2se/1.4.2/docs/guide/lang/assert.html, Last access: June
2007
30. Davis, R., Ruby QuickRef, 2004,
http://www.zenspider.com/Languages/Ruby/QuickRef.html, Last access:
June 2008

- 415 -

Notas POO 2008 PDF

Cargado por

Copyright:

Formatos disponibles

Notas POO 2008 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Notas POO 2008 PDF

Cargado por

Copyright:

Formatos disponibles

PROGRAMACIÓN ORIENTADA

Carlos Alberto Fernández y Fernández

Carlos Alberto Fernández y Fernández

Arreglos .......................................................................................................... 106

Alcance de Clase en Java ............................................................................... 144

Sobrecarga de operadores en C++ ................................................................. 181

Herencia en C++.............................................................................................. 193

Carlos Alberto Fernández y Fernández

Introducción ................................................................................................... 193

Herencia en Ruby............................................................................................ 243

Control de acceso a miembros en Ruby .......................................................... 246

Asociaciones entre clases en C++ ................................................................... 259

UMLGEC ++ ................................................................................................... 277

Objetos compuestos en Java ........................................................................... 279

Objetos compuestos en Ruby.......................................................................... 284

Funciones virtuales y polimorfismo en C++ .................................................. 289

Polimorfismo .................................................................................................. 293

Standard Template Library (STL) ................................................................ 341

Clases Genéricas en Java................................................................................. 344

Biblioteca de Clases Genéricas en Java ......................................................... 347

Manejo de Excepciones ................................................................................... 350

Manejo de Excepciones en C++...................................................................... 351

Lista de Excepciones ................................................................................... 363

Adaptadores ................................................................................................. 399

Carlos Alberto Fernández y Fernández

Eclipse es desarrollado como un proyecto de codigo abierto lanzada en

Es desarrollada en Java por lo que puede ejecutarse en un amplio rango de

• Eclipse + JDT = Java IDE

Trabaja bajo “workbenchs” que determinan la interfaz del usuario centrada

Carlos Alberto Fernández y Fernández

Los recursos son almacenados en el espacio de trabajo (workspace) el cual es un

Eclipse, sus componentes y documentación pueden ser obtenidos de:

Para trabajar en este curso se requerirá preferentemente:

1. Java 1.5 o 1.6

Carlos Alberto Fernández y Fernández

Tips para instalar CDT (C/C++ Development Toolkit) en Eclipse en Windows:

1. Instalar un compilador de C/C++

En el caso de Ruby, el interprete puede obtenerse de: http://www.ruby-

El RDT para eclipse se instala como el CDT y se obtiene de:

Posteriormente se tiene que especificar en Eclipse la ruta del interprete.

Carlos Alberto Fernández y Fernández

Ahora comentaremos algunas características de C++ que no tienen que ver

Los comentarios en C son:

En C++ los comentarios pueden ser además de una sola línea:

Acabando el comentario al final de la línea, lo que quiere decir que el

En C, la salida y entrada estándar estaba dada por printf y scanf principalmente

- cout Utiliza el flujo salida estándar.

- cin Utiliza el flujo de entrada estándar.

Carlos Alberto Fernández y Fernández

Los operadores de inserción y de extracción de flujo no requieren cadenas

En el caso de el operador de extracción (>>) no se requiere el operador de

De tal forma un código de desplegado con printf y scanf de la forma (usando

Sería en C++ de la siguiente manera:

cout << "Número";

Las funciones en línea, se refiere a introducir un calificador inline a una

Ayuda a reducir el número de llamadas a funciones reduciendo el tiempo de

A diferencia de las macros, las funciones inline si incluyen verificación de

Carlos Alberto Fernández y Fernández

El compilador desecha las solicitudes inline para programas que incluyan un