Este documento presenta un proyecto de estudiantes de Ingeniería Electrónica y Redes de Información sobre un sistema de música. El proyecto permite ingresar, buscar, modificar y eliminar información sobre canciones bailables. Explica conceptos como Eclipse, diagramas UML, clases y herencia que sustentan el proyecto.

1. ESCUELA POLITÉCNICA NACIONAL
INGENIERÍA EN ELECTRÓNICA Y
REDES DE INFORMACIÓN
TEMA DE PROYECTO
MUSICA
INTEGRANTES:
Aguayo César
Cárdenas Cristel
Suasnavas Carmen
PROFESOR:
ING. RODRIGO CHANCUSIG

2. INDICE
1. TEMA........... ........... ........... ........... ................................................................................................................... 2
2. OBJETIVOS……………………………………………………………………………………………………...2
3.ALCANCE ……………………………………………………………………………………………………….2
4.SUSTENTACIÓN TEÓRICA……………………………………………………………………………….……3
Eclipse…………………………………………………………………………………………..…..…….3
Diagrama UML……………………………………………………………………………………….…..4
Diagrama de Clases ………………………………………………………………………..…...5
Algunos Elementos Utilizados ………………………………………………………………..…………9
Interfaces …………………………………………………………………………..…………10
Variables y Métodos estáticos …………………………………………………….…………11
Integer …………………………………………………………………………………………..………14
Excepciones ………………………………………………………………………………...…………..15
Actualización de información…………………………………………………….……………………..23
Archivos de texto…………………………………………………………………………………..……24
5.CONCLUSIONES Y RECOMENDACIONES ………………………………………………….…….…….…25
6.REFERENCIAS Y BIBLIOGRAFÍA……………………………………………………………………...….…26
ESCUELA POLITÉCNICA NACIONAL
INGENIERÍA ELECTRÓNICA Y REDES DE INFORMACIÓN
PROGRAMACIÓN ORIENTADA A OBJETOS.
PROYECTO FINAL
TEMA: MUSICA
OBJETIVO.- Implementar un pequeño sistema que permita:
• Ingresar información
• Búsqueda de información
2

3. • Modificar información
• Borrar información
• Almacenar en un archivo de texto.
ALCANCE:
El presente trabajo cuanta con diferentes opciones para el manejo de información de Música
Bailable
Codigo de la cancion.- dato de tipo int, código de la canción que queremos ingresar
Nombre de la canción.- dato de tipo int, nombre de la canción ingresada
Autor de canción.- dato de tipo char, autor de la canción
Ano de Lanzamiento- dato de tipo int, Año de lanzamiento de la canción
Tipo de Canción.- dato de tipo char, Que clase de canción es
Tiempo de duración de la canción.- dato de tipo char, tiempo de duración de la canción
Los métodos de todas las subclases son heredadas de la súper clase Música
Ingresar( );
Modificar( );
Eliminar( );
Ingresar( );
Permite ingresar nuevas canciones del tipo:
Código, Nombre. Autor , Año, Tipo, Duración
Eliminar( );
Permite observar y eliminar las canciones que se han creado, mediante un ID
3

4. SUSTENTACIÓN TEÓRICA.
ECLIPSE
Eclipse es un entorno de desarrollo integrado de código abierto multiplataforma para
desarrollar lo que el proyecto llama "Aplicaciones de Cliente Enriquecido", opuesto a las
aplicaciones "Cliente-liviano" basadas en navegadores. Esta plataforma, típicamente ha sido
usada para desarrollar entornos de desarrollo integrados (del inglés IDE), como el IDE de
Java llamado Java Development Toolkit (JDT) y el compilador (ECJ) que se entrega como
parte de Eclipse (y que son usados también para desarrollar el mismo Eclipse). Sin embargo,
también se puede usar para otros tipos de aplicaciones cliente, como BitTorrent Azureus.
Arquitectura
La base para Eclipse es la Plataforma de cliente enriquecido (del Inglés Rich Client Platform
RCP). Los siguientes componentes constituyen la plataforma de cliente enriquecido:
• Plataforma principal - inicio de Eclipse, ejecución de plugins
• OSGi - una plataforma para bundling estándar.
• El Standard Widget Toolkit (SWT) - Un widget toolkit portable.
• JFace - manejo de archivos, manejo de texto, editores de texto
• El Workbench de Eclipse - vistas, editores, perspectivas, asistentes
Los widgets de Eclipse están implementados por un herramienta de widget para Java llamada
SWT, a diferencia de la mayoría de las aplicaciones Java, que usan las opciones estándar
Abstract Window Toolkit (AWT) o Swing. La interfaz de usuario de Eclipse también tiene
una capa GUI intermedia llamada JFace, la cual simplifica la construcción de aplicaciones
basada en SWT.
En cuanto a las aplicaciones clientes, eclipse provee al programador con frameworks muy ricos
para el desarrollo de aplicaciones gráficas, definición y manipulación de modelos de software,
aplicaciones web, etc. Por ejemplo, GEF (Graphic Editing Framework - Framework para la
edición gráfica) es un plugin de Eclipse para el desarrollo de editores visuales que pueden ir
desde procesadores de texto wysiwyg hasta editores de diagramas UML, interfaces gráficas para
el usuario (GUI), etc. Dado que los editores realizados con GEF "viven" dentro de Eclipse,
además de poder ser usados conjuntamente con otros plugins, hacen uso de su interfaz gráfica
personalizable y profesional.
4

5. Características
La versión actual de Eclipse dispone de las siguientes características:
• Editor de texto
• Resaltado de sintaxis
• Compilación en tiempo real
• Pruebas unitarias con JUnit
• Control de versiones con CVS
• Integración con Ant
• Asistentes (wizards): para creación de proyectos, clases, tests, etc.
• Refactorización
Asimismo, a través de "plugins" libremente disponibles es posible añadir:
• Control de versiones con Subversion.
• Integración con Hibernate.
DIAGRAMA UML
Lenguaje Unificado de Modelado (UML, por sus siglas en inglés, Unified Modeling
Language) es el lenguaje de modelado de sistemas de software más conocido y utilizado
en la actualidad; está respaldado por el OMG (Object Management Group). Es un
lenguaje gráfico para visualizar, especificar, construir y documentar un sistema. UML
ofrece un estándar para describir un "plano" del sistema (modelo), incluyendo aspectos
conceptuales tales como procesos de negocio y funciones del sistema, y aspectos
concretos como expresiones de lenguajes de programación, esquemas de bases de datos
y componentes reutilizables.
Es importante resaltar que UML es un "lenguaje" para especificar y no para describir
métodos o procesos. Se utiliza para definir un sistema, para detallar los artefactos en el
sistema y para documentar y construir. En otras palabras, es el lenguaje en el que está
descrito el modelo.
Se puede aplicar en el desarrollo de software entregando gran variedad de formas para
dar soporte a una metodología de desarrollo de software (tal como el Proceso Unificado
Racional o RUP), pero no especifica en sí mismo qué metodología o proceso usar.
5

6. UML no puede compararse con la programación estructurada, pues UML significa
(Lengua de Modelación Unificada), no es programación, solo se diagrama la realidad de
una utilización en un requerimiento. Mientras que, programación estructurada, es una
forma de programar como lo es la orientación a objetos, sin embargo, la orientación a
objetos viene siendo un complemento perfecto de UML, pero no por eso se toma UML
sólo para lenguajes orientados a objetos
UML cuenta con varios tipos de diagramas, los cuales muestran diferentes aspectos de
las entidades representadas.
Modelo de Clases Utilizando Estándar UML.
Un diagrama de clases sirve para visualizar las relaciones entre las clases que
involucran el sistema, las cuales pueden ser asociativas, de herencia, de uso y de
contenido.
Un diagrama de clases esta compuesto por los siguientes elementos:
• Clase: atributos, métodos y visibilidad.
• Relaciones: Herencia, Composición, Agregación, Asociación y Uso.
ELEMENTOS.
• Clase.
Es la unidad básica que encapsula toda la información de un Objeto (un objeto es una
instancia de una clase). A través de ella se puede modelar el entorno en estudio (una
Casa, un Auto, una Cuenta Corriente, etc.).
En UML, una clase es representada por un rectángulo que posee tres divisiones:
En donde:
o Superior: Contiene el nombre de la Clase.
o Intermedio: Contiene los atributos (o variables de instancia) que
caracterizan a la Clase (pueden ser private, protected o public).
6

7. o Inferior: Contiene los métodos u operaciones, los cuales son la forma
como interactúa el objeto con su entorno (dependiendo de la visibilidad:
private, protected o public).
Ejemplo:
Una Cuenta Corriente que posee como característica:
o Balance
Puede realizar las operaciones de:
o Depositar
o Girar
o y Balance
El diseño asociado es:
ATRIBUTOS Y MÉTODOS.
Atributos.
Los atributos o características de una Clase pueden ser de tres tipos, los que definen el
grado de comunicación y visibilidad de ellos con el entorno, estos son:
• public (+, ): Indica que el atributo será visible tanto dentro como fuera de la
clase, es decir, es accesible desde todos lados.
• private (-, ): Indica que el atributo sólo será accesible desde dentro de la
clase (sólo sus métodos lo pueden accesar).
• protected (#, ): Indica que el atributo no será accesible desde fuera de la
clase, pero si podrá ser accesado por métodos de la clase además de las
subclases que se deriven (ver herencia).
Métodos.
Los métodos u operaciones de una clase son la forma en como ésta interactúa con su
entorno, éstos pueden tener las características:
7

8.  public (+, ): Indica que el método será visible tanto dentro como fuera de la
clase, es decir, es accesible desde todos lados.
 private (-, ): Indica que el método sólo será accesible desde dentro de la
clase (sólo otros métodos de la clase lo pueden accesar).
 protected (#, ): Indica que el método no será accesible desde fuera de la
clase, pero si podrá ser accesado por métodos de la clase además de métodos de
las subclases que se deriven (ver herencia).
RELACIONES ENTRE CLASES.
Ya definido el concepto de Clase, es necesario entender como se pueden interrelacionar
dos o más clases (cada uno con características y objetivos diferentes).
Antes es necesario explicar el concepto de cardinalidad de relaciones: En UML, la
cardinalidad de las relaciones indica el grado y nivel de dependencia, se anotan en cada
extremo de la relación y éstas pueden ser:
• uno o muchos: 1..* (1..n)
• 0 o muchos: 0..* (0..n)
• número fijo: m (m denota el número).
Herencia (Especialización/Generalización):
Indica que una subclase hereda los métodos y atributos especificados por una Super
Clase, por ende la Subclase además de poseer sus propios métodos y atributos, poseerá
las características y atributos visibles de la Super Clase (public y protected), ejemplo:
Agregación:
Para modelar objetos complejos, n bastan los tipos de datos básicos que proveen los
lenguajes: enteros, reales y secuencias de caracteres. Cuando se requiere componer
objetos que son instancias de clases definidas por el desarrollador de la aplicación,
tenemos dos posibilidades:
 Por Valor: Es un tipo de relación estática, en donde el tiempo de vida del objeto
incluido esta condicionado por el tiempo de vida del que lo incluye. Este tipo de
relación es comúnmente llamada Composición (el Objeto base se construye a
partir del objeto incluido, es decir, es "parte/todo").
 Por Referencia: Es un tipo de relación dinámica, en donde el tiempo de vida del
objeto incluido es independiente del que lo incluye. Este tipo de relación es
comúnmente llamada Agregación (el objeto base utiliza al incluido para su
funcionamiento).
Asociación:
8

9. La relación entre clases conocida como Asociación, permite asociar objetos que
colaboran entre si. Cabe destacar que no es una relación fuerte, es decir, el tiempo de
vida de un objeto no depende del otro.
Ejemplo:
Un cliente puede tener asociadas muchas Ordenes de Compra, en cambio una orden de
compra solo puede tener asociado un cliente.
Dependencia o Instanciación (uso):
Representa un tipo de relación muy particular, en la que una clase es instanciada (su
instanciación es dependiente de otro objeto/clase). Se denota por una flecha punteada.
El uso más particular de este tipo de relación es para denotar la dependencia que tiene
una clase de otra, como por ejemplo una aplicación grafica que instancia una ventana (la
creación del Objeto Ventana esta condicionado a la instanciación proveniente desde el
objeto Aplicación):
Cabe destacar que el objeto creado (en este caso la Ventana gráfica) no se almacena
dentro del objeto que lo crea (en este caso la Aplicación).
CASOS PARTICULARES.
Clase Abstracta.
Una clase abstracta se denota con el nombre de la clase y de los métodos con letra
"itálica". Esto indica que la clase definida no puede ser instanciada pues posee métodos
abstractos (aún no han sido definidos, es decir, sin implementación). La única forma de
utilizarla es definiendo subclases, que implementan los métodos abstractos definidos.
9

10. Clase parametrizada.
Una clase parametrizada se denota con un sub-cuadro en el extremo superior de la clase,
en donde se especifican los parámetros que deben ser pasados a la clase para que esta
pueda ser instanciada. El ejemplo más típico es el caso de un Diccionario en donde una
llave o palabra tiene asociado un significado, pero en este caso las llaves y elementos
pueden ser genéricos. La genericidad puede venir dada de un Template (como en el caso
de C++) o bien de alguna estructura predefinida (especialización a través de clases).
En el ejemplo no se especificaron los atributos del Diccionario, pues ellos dependerán
exclusivamente de la implementación que se le quiera dar.
ALGUNOS CONCEPTOS UTILIZADOS EN EL PROGRAMA
Después de haber visto los conceptos más importantes sobre la clase objeto, debemos
incursionarnos en los formatos que son indispensables en la elaboración de clases y
subclases para manejar los diferentes métodos aplicados en la realización de este
trabajo.
A continuación vamos a puntualizar los más destacados e importantes dentro del código
fuente, pues las demás atributos se lo toma como aprendidos en clase y sobrentendidos
en el transcurso del curso.
• This y Super
Al acceder a variables de instancia de una clase, la palabra clave this hace referencia a
los miembros de la propia clase. Volviendo al ejemplo de MiClase, se puede añadir otro
constructor de la forma siguiente:
public class MiClase {
int i;
public MiClase() {
i = 10;
}
// Este constructor establece el valor de i
public MiClase( int valor ) {
this.i = valor; // i = valor
}
public void Suma_a_i( int j ) {
i = i + j;
}
}
10

11. Aquí this.i se refiere al entero i en la clase MiClase .
Si se necesita llamar al método padre dentro de una clase que ha reemplazado ese
método, se puede hacer referencia al método padre con la palabra clave super :
import MiClase;
public class MiNuevaClase extends MiClase {
public void Suma_a_i( int j ) {
i = i + ( j/2 );
super.Suma_a_i( j );
}
}
• Herencia
La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos
de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase
Pato, que es una especialización de Ave.
class Pato extends Ave {
int numero_de_patas;
}
La palabra clave extends se usa para generar una subclase (especialización) de un
objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de
Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos
y variables de instancia. Se dice que Pato deriva o hereda de Ave.
Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando
nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada
sustituyendo a la función Suma_a_i() :
import MiClase;
public class MiNuevaClase extends MiClase {
public void Suma_a_i( int j ) {
i = i + ( j/2 );
}
}
Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa
a 10, pero la llamada al método Suma_a_i() produce un resultado diferente:
MiNuevaClase mnc;
mnc = new MiNuevaClase();
mnc.Suma_a_i( 10 );
• Interfaces
Los métodos abstractos son útiles cuando se quiere que cada implementación de la clase
parezca y funcione igual, pero necesita que se cree una nueva clase para utilizar los
métodos abstractos.
Los interfaces proporcionan un mecanismo para abstraer los métodos a un nivel
superior.
11

12. Un interface contiene una colección de métodos que se implementan en otro lugar. Los
métodos de una clase son public , static y final .
La principal diferencia entre interface y abstract es que un interface proporciona un
mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a
utilizar la herencia.
Por ejemplo:
public interface VideoClip {
// comienza la reproduccion del video
void play();
// reproduce el clip en un bucle
void bucle();
// detiene la reproduccion
void stop();
}
Las clases que quieran utilizar el interface VideoClip utilizarán la palabra implements y
proporcionarán el código necesario para implementar los métodos que se han definido
para el interface:
class MiClase implements VideoClip {
void play() {
<código>
}
void bucle() {
<código>
}
void stop() {
<código>
}
Al utilizar implements para el interface es como si se hiciese una acción de copiar-y-
pegar del código del interface, con lo cual no se hereda nada, solamente se pueden usar
los métodos.
• Variables y Métodos Estáticos
En un momento determinado se puede querer crear una clase en la que el valor de una
variable de instancia sea el mismo (y de hecho sea la misma variable) para todos los
objetos instanciados a partir de esa clase. Es decir, que exista una única copia de la
variable de instancia. Se usará para ello la palabra clave static .
class Documento extends Pagina {
static int version = 10;
}
El valor de la variable version será el mismo para cualquier objeto instanciado de la
clase Documento . Siempre que un objeto instanciado de Documento cambie la variable
version , ésta cambiará para todos los objetos.
De la misma forma se puede declarar un método como estático, lo que evita que el
método pueda acceder a las variables de instancia no estáticas:
12

13. class Documento extends Pagina {
static int version = 10;
int numero_de_capitulos;
static void annade_un_capitulo() {
numero_de_capitulos++; // esto no funciona
}
static void modifica_version( int i ) {
version++; // esto si funciona
}
}
La modificación de la variable numero_de_capitulos no funciona porque se está
violando una de las reglas de acceso al intentar acceder desde un método estático a una
variable no estática.
Todas las clases que se derivan, cuando se declaran estáticas, comparten la misma
página de variables; es decir, todos los objetos que se generen comparten la misma zona
de memoria. Las funciones estáticas se usan para acceder solamente a variables
estáticas.
class UnaClase {
int var;
UnaClase()
{
var = 5;
}
UnaFuncion()
{
var += 5;
}
}
En el código anterior, si se llama a la función UnaFuncion a través de un puntero a
función, no se podría acceder a var , porque al utilizar un puntero a función no se pasa
implícitamente el puntero al propio objeto ( this ). Sin embargo, sí se podría acceder a
var si fuese estática, porque siempre estaría en la misma posición de memoria para
todos los objetos que se creasen de UnaClase.
• La clase StringBuffer
Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y
StringBuffer . Un objeto String representa una cadena alfanumérica de un valor
constante que no puede ser cambiada después de haber sido creada. Un objeto
StringBuffer representa una cadena cuyo tamaño puede variar.
La clase StringBuffer dispone de muchos métodos para modificar el contenido de los
objetos StringBuffer. Si el contenido de una cadena va a ser modificado en un
programa, habrá que sacrificar el uso de objetos String en beneficio de StringBuffer,
que aunque consumen más recursos del sistema, permiten ese tipo de manipulaciones.
Al estar la mayoría de las características de los StringBuffers basadas en su tamaño
variable, se necesita un nuevo método de creación:
StringBuffer();
StringBuffer( int len );
StringBuffer( String str );
13

14. Se puede crear un StringBuffer vacío de cualquier longitud y también se puede utilizar
un String como punto de partida para un StringBuffer.
StringBuffer Dos = new StringBuffer( 20 );
StringBuffer Uno = new StringBuffer( "Hola Mundo" );
Cambio de Tamaño
El cambio de tamaño de un StringBuffer necesita varias funciones específicas para
manipular el tamaño de las cadenas:
int length();
char charAt( int index );
void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin );
String toString();
void setLength( int newlength );
void setCharAt( int index,char ch );
int capacity();
void ensureCapacity( int minimum );
void copyWhenShared();
Obervar que una de las funciones devuelve una cadena constante normal de tipo String.
Este objeto se puede usar con cualquier función String, como por ejemplo, en las
funciones de comparación.
Modificación del Contenido
Para cambiar el contenido de un StringBuffer, se pueden utilizar dos métodos: append()
e insert() .
En el ejemplo CadAppend.java , vemos el uso de estos dos métodos:
class CadAppend {
public static void main( String args[] ) {
StringBuffer str = new StringBuffer( "Hola" );
str.append( " Mundo" );
System.out.println( str );
}
}
Operadores de Concatenación
Hay que recordar que los operadores " + " y " += " también se pueden aplicar a cadenas.
Ambos realizan una concatenación y están implementados con objetos StringBuffer.
Por ejemplo, la sentencia:
String s = "¿Qué" + " tal ?";
es interpretada por el compilador como:
String s =
new StringBuffer().append( "¿Qué" ).append( " tal ?" ).toString();
y se marcaría el StringBuffer para borrarlo ya que el contenido pasa al objeto String.
14

15. • La clase Integer
Cada tipo numérico tiene su propia clase de objetos. Así el tipo int tiene el objeto
Integer . De la misma forma que con la clase Character , se han codificado muchas
funciones útiles dentro de los métodos de la clase Integer .
Declaraciones
La primera sentencia creará una variable int y la segunda un objeto Integer:
Integer.MIN_VALUE;
Integer.MAX_VALUE;
Valores de Integer
Integer.MIN_VALUE;
Integer.MAX_VALUE;
Métodos de Integer
String Integer.toString( int i,int base );
String Integer.toString( int i );
int I.parseInt( String s,int base );
int I.parseInt( String s );
Integer Integer.valueOf( String s,int base );
Integer Integer.valueOf( String s );
int I.intValue();
long I.longValue();
float I.floatValue();
double I.doubleValue();
String I.toString();
int I.hashCode();
boolean I.equals( Object obj );
Los valores boolean también tienen su tipo asociado Boolean , aunque en este caso hay
menos métodos implementados que para el resto de las clases numéricas.
Declaraciones
La primera sentencia creará una variable boolean y la segunda un objeto Boolean:
boolean b;
Boolean B;
Valores de Boolean
Boolean.TRUE;
Boolean.FALSE;
Métodos de Boolean
boolean B.booleanValue();
String B.toString();
boolean B.equals( Object obj );
15

16. • Excepciones
try-catch-throw
try {
sentencias;
} catch( Exception ) {
sentencias;
}
Java implementa excepciones para facilitar la construcción de código robusto. Cuando
ocurre un error en un programa, el código que encuentra el error lanza una excepción,
que se puede capturar y recuperarse de ella. Java proporciona muchas excepciones
predefinidas.
El manejo y control de excepciones es tan importante en Java que debe ser tratado en un
capítulo aparte, aunque sirva este punto como mención previa de su existencia.
• Control General del Flujo
break
break [etiqueta];
La sentencia break puede utilizarse en una sentencia switch o en un bucle. Cuando se
encuentra en una sentencia switch, break hace que el control del flujo del programa pase a
la siguiente sentencia que se encuentre fuera del entorno del switch. Si se encuentra en
un bucle, hace que el flujo de ejecución del programa deje el ámbito del bucle y pase a
la siguiente sentencia que venga a continuación del bucle.
Java incorpora la posibilidad de etiquetar la sentencia break, de forma que el control
pasa a sentencias que no se encuentran inmediatamente después de la sentencia switch o
del bucle, es decir, saltará a la sentencia en donde se encuentre situada la etiqueta. La
sintaxis de una sentencia etiquetada es la siguiente:
etiqueta: sentencia;
continue
continue [etiqueta];
La sentencia continue no se puede utilizar en una sentencia switch, sino solamente en
bucles. Cuando se encuentra esta sentencia en el discurrir normal de un programa Java,
la iteración en que se encuentre el bucle finaliza y se inicia la siguiente.
Java permite el uso de etiquetas en la sentencia continue, de forma que el funcionamiento
normal se ve alterado y el salto en la ejecución del flujo del programa se realizará a la
sentencia en la que se encuentra colocada la etiqueta.
Por ejemplo, al encontrarse con bucles anidados, se pueden utilizar etiquetas para poder
salir de ellos:
16

17. uno: for( ) {
dos: for( ) {
continue; // seguiría en el bucle interno
continue uno; // seguiría en el bucle principal
break uno; // se saldría del bucle principal
}
}
Hay autores que sugieren que el uso de sentencias break y continue etiquetadas
proporciona una alternativa al infame goto (que C++ todavía soporta, pero Java no,
aunque reserva la palabra). Quizá se así, pero el entorno de uso de las sentencias
etiquetadas break y continue es mucho más restrictivo que un goto. Concretamente, parece
que un break o continue con etiqueta, compila con éxito solamente si la sentencia en que
se encuentra colocada la etiqueta es una sentencia a la que se pueda llegar con un break o
continue normal.
return
return expresión;
La sentencia return se utiliza para terminar un método o función y opcionalmente
devolver un valor al método de llamada.
En el código de una función siempre hay que ser consecuentes con la declaración que se
haya hecho de ella. Por ejemplo, si se declara una función para que devuelva un entero,
es imprescindible colocar un return final para salir de esa función, independientemente
de que haya otros en medio del código que también provoquen la salida de la función.
En caso de no hacerlo se generará un Warning, y el código Java no se puede compilar
con Warnings.
int func() {
if( a == 0 )
return 1;
return 0; // es imprescindible porque se retorna un entero
}
Si el valor a retornar es void, se puede omitir ese valor de retorno, con lo que la sintaxis
se queda en un sencillo:
return;
y se usaría simplemente para finalizar el método o función en que se encuentra, y
devolver el control al método o función de llamada.
Esta sentencia se puede utilizar para mostrar uno de los problemas para los que Java
está destinado a corregir. En C++ se permite que los valores de retorno de una función o
método puedan ser por valor o por referencia. Cuando se devuelve un valor por
referencia, o un puntero, en C++, hay que asegurarse de que el objeto referenciado
continúe existiendo a la terminación del método. Por ejemplo, si se devuelve un puntero
o una referencia a una variable local de la función, pueden presentarse problemas,
porque esa variable deja de existir tan pronto como finaliza la función.
17

18. El compilador Borland C++ utilizado por el autor para realizar pruebas, no permite que
se devuelva una referencia a una variable local, pero sí que permite devolver un puntero
a esa variable. El siguiente programa, java409.cpp, es muy simple e ilustra esto. Crea un
array en la función principal para modificar la memoria y luego utiliza el puntero
devuelto para presentar el contenido de la memoria a la que apunta ese puntero. El
programa presenta en pantalla porquería, porque después de que termine la función, el
puntero apunta a una dirección de memoria que ya no es válida para el programa. Sin
embargo, compilando la aplicación con GNU C++ y corriendo sobre Linux, el valor que
se presenta sí es el correcto.
#include <iostream.h>
int *test() { // Declara la variable local a la función
int variableLocal = 6; // Guarda su dirección en un puntero
int *puntero = &variableLocal;
// Devuelve el puntero a la variable local
return puntero;
}
void main() {
// Recoge el puntero devuelto por la función de test
int *punteroMain = test();
// Rellena con cosas la memoria
int memArray[5] = { 10,11,12,13,14 };
// Presenta en pantalla el contenido de la zona a que apunta el
// puntero
cout << "El contenido de la memoria es " << *punteroMain;
}
Aparentemente en Java, solamente se puede retornar por valor. En el caso de tipos
básicos, se devuelve una copia del item retornado. Si no se quiere devolver una copia,
siempre está la posibilidad de utilizar las versiones objeto de los tipos básicos.
• Manejo de excepciones
Vamos a mostrar como se utilizan las excepciones, reconvirtiendo nuestro applet de
saludo a partir de la versión iterativa de HolaIte.java :
import java.awt.*;
import java.applet.Applet;
public class HolaIte extends Applet {
private int i = 0;
private String Saludos[] = {
"Hola Mundo!",
"HOLA Mundo!",
"HOLA MUNDO!!"
};
public void paint( Graphics g ) {
g.drawString( Saludos[i],25,25 );
i++;
}
}
18

19. Normalmente, un programa termina con un mensaje de error cuando se lanza una
excepción. Sin embargo, Java tiene mecanismos para excepciones que permiten ver qué
excepción se ha producido e intentar recuperarse de ella.
Vamos a reescribir el método paint() de nuestra versión iterativa del saludo:
La palabra clave finally define un bloque de código que se quiere que sea ejecutado
siempre, de acuerdo a si se capturó la excepción o no. En el ejemplo anterior, la salida
en la consola, con i=4 sería:
• Capturar Excepciones
Las excepciones lanzadas por un método que pueda hacerlo deben recoger en bloque
try/catch o try/finally .
try
Es el bloque de código donde se prevé que se genere una excepción. Es como si
dijésemos "intenta estas sentencias y mira a ver si se produce una excepción". El bloque
try tiene que ir seguido, al menos, por una cláusula catch o una cláusula finally
catch
Es el código que se ejecuta cuando se produce la excepción. Es como si dijésemos
"controlo cualquier excepción que coincida con mi argumento". En este bloque
tendremos que asegurarnos de colocar código que no genere excepciones. Se pueden
colocar sentencias catch sucesivas, cada una controlando una excepción diferente. No
debería intentarse capturar todas las excepciones con una sola cláusula, como esta:
catch( Excepcion e ) { ...
Esto representaría un uso demasiado general, podrían llegar muchas más excepciones de
las esperadas. En este caso es mejor dejar que la excepción se propague hacia arriba y
dar un mensaje de error al usuario.
Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a través
del argumento, excepciones semejantes
que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque. El
operador instanceof se utiliza para identificar exactamente cual ha sido la identidad de
la excepción.
finally
Es el bloque de código que se ejecuta siempre, haya o no excepción. Hay una cierta
controversia entre su utilidad, pero, por ejemplo, podría servir para hacer un log o un
seguimiento de lo que está pasando, porque como se ejecuta siempre puede dejarnos
grabado si se producen excepciones y nos hemos recuperado de ellas o no.
19

20. • Excepciones Predefinidas
Las excepciones predefinidas y su jerarquía de clases es la que se muestra en la figura:
Los nombres de las excepciones indican la condición de error que representan. Las
siguientes son las excepciones predefinidas más frecuentes que se pueden encontrar:
ArithmeticException
Las excepciones aritméticas son típicamente el resultado de una división por 0:
int i = 12 / 0;
NullPointerException
Se produce cuando se intenta acceder a una variable o método antes de ser definido:
class Hola extends Applet {
Image img;
paint( Graphics g ) {
g.drawImage( img,25,25,this );
}
}
20

21. IncompatibleClassChangeException
El intento de cambiar una clase afectada por referencias en otros objetos,
específicamente cuando esos objetos todavía no han sido recompilados.
ClassCastException
El intento de convertir un objeto a otra clase que no es válida.
y = (Prueba)x; // donde
x no es de tipo Prueba
NegativeArraySizeException
Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un array.
OutOfMemoryException
¡No debería producirse nunca! El intento de crear un objeto con el operador new ha
fallado por falta de memoria. Y siempre tendría que haber memoria suficiente porque el
garbage collector se encarga de proporcionarla al ir liberando objetos que no se usan y
devolviendo memoria al sistema.
NoClassDefFoundException
Se referenció una clase que el sistema es incapaz de encontrar.
ArrayIndexOutOfBoundsException
Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un
elemento de un array más allá de los límites definidos inicialmente para ese array.
UnsatisfiedLinkException
Se hizo el intento de acceder a un método nativo que no existe. Aquí no existe un
método a.kk
class A {
native void kk();
}
InternalException
Este error se reserva para eventos que no deberían ocurrir. Por definición, el usuario
nunca debería ver este error y esta excepción no debería lanzarse.
• Ficheros
Todos los lenguajes de programación tienen alguna forma de interactuar con los
sistemas de ficheros locales; Java no es una excepción.
21

22. Cuando se desarrollan applets para utilizar en red, hay que tener en cuenta que la
entrada/salida directa a fichero es una violación de seguridad de acceso. Muchos
usuarios configurarán sus navegadores para permitir el acceso al sistema de ficheros,
pero otros no.
Antes de realizar acciones sobre un fichero, necesitamos un poco de información sobre
ese fichero. La clase File proporciona muchas utilidades relacionadas con ficheros y con
la obtención de información básica sobre esos ficheros.
Creación de un objeto File
Para crear un objeto File nuevo, se puede utilizar cualquiera de los tres constructores
siguientes:
File miFichero;
miFichero = new File( "/etc/kk" );
o
miFichero = new File( "/etc","kk" );
o
File miDirectorio = new File( "/etc" );
miFichero = new File( miDirectorio,"kk" );
El constructor utilizado depende a menudo de otros objetos File necesarios para el
acceso. Por ejemplo, si sólo se utiliza un fichero en la aplicación, el primer constructor
es el mejor. Si en cambio, se utilizan muchos ficheros desde un mismo directorio, el
segundo o tercer constructor serán más cómodos. Y si el directorio o el fichero es una
variable, el segundo constructor será el más útil.
• Ficheros de Acceso Aleatorio
A menudo, no se desea leer un fichero de principio a fin; sino acceder al fichero como
una base de datos, donde se salta de un registro a otro; cada uno en diferentes partes del
fichero. Java proporciona una clase RandomAccessFile para este tipo de entrada/salida.
Creación de un Fichero de Acceso Aleatorio
Hay dos posibilidades para abrir un fichero de acceso aleatorio:
Con el nombre del fichero:
miRAFile = new RandomAccessFile( String nombre,String modo );
Con un objeto File:
miRAFile = new RandomAccessFile( File fichero,String modo );
El argumento modo determina si se tiene acceso de sólo lectura ( r ) o de
lectura/escritura ( r/w ). Por ejemplo, se puede abrir un fichero de una base de datos
para actualización:
RandomAccessFile miRAFile;
miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" );
22

23. Acceso a la Información
Los objetos RandomAccessFile esperan información de lectura/escritura de la misma
manera que los objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones
read() y write() de las clases DataInputStream y DataOutputStream.
También se tienen muchos métodos para moverse dentro de un fichero:
long getFilePointer();
Devuelve la posición actual del puntero del fichero
void seek( long pos );
Coloca el puntero del fichero en una posición determinada. La posición se da como un
desplazamiento en bytes desde el comienzo del fichero. La posición 0 marca el
comienzo de ese fichero.
long length();
Devuelve la longitud del fichero. La posición length() marca el final de ese fichero.
Actualización de Información
Se pueden utilizar ficheros de acceso aleatorio para añadir información a ficheros
existentes:
Listas
Hay varias implementaciones de List, siendo ArrayList la que debería ser la elección
por defecto, en caso de no tener que utilizar las características que proporcionan las
demás implementaciones.
ArrayList
Es una Lista volcada en un Array. Se debe utilizar en lugar de Vector como
almacenamiento de objetos de propósito general. Permite un acceso aleatorio muy
rápido a los elementos, pero realiza con bastante lentitud las operaciones de insertado y
borrado de elementos en medio de la Lista. Se puede utilizar un ListIterator para
moverse hacia atrás y hacia delante en la Lista, pero no para insertar y eliminar
elementos.
Sets
Set tiene exactamente el mismo interfaz que Collection, y no hay ninguna
funcionalidad extra, como en el caso de las Listas. Un Set es exactamente una
Colección, pero tiene utilizada en un entorno determinado, que es ideal para el uso de la
herencia o el polimorfismo. Un Set sólo permite que exista una instancia de cada objeto.
23

24. A continuación se muestran las diferentes implementaciones de Set, debiendo utilizarse
HashSet en general, a no ser que se necesiten las características proporcionadas por
alguna de las otras implementaciones.
Set (interfaz)
Cada elemento que se añada a un Set debe ser único, ya que el otro caso no se añadirá
porque el Set no permite almacenar elementos duplicados. Los elementos incorporados
al Conjunto deben tener definido el método equals(), en aras de establecer
comparaciones para eliminar duplicados. Set tiene el mismo interfaz que Collection, y
no garantiza el orden en que se encuentren almacenados los objetos que contenga.
ARCHIVOS DE TEXTO
Si se desea procesar datos de un archivo existente, se debe:
1. Abrir el archivo
2. Leer o introducir los datos en las variables, un elemento a la vez
3. Cerrar el archivo cuando se termine de trabajar con él
Para transferir algunos datos de ciertas variables a un archivo, se debe:
1. Abrir el archivo
2. Extraer o escribir los elementos en la secuencia requerida
3. Cerrar el archivo cuando se termine de trabajar con él
Al leer un archivo, todo lo que puede hacerse es leer el siguiente elemento. Si, por
ejemplo, quisiéramos examinar el último elemento, tendríamos que codificar un ciclo
para leer cada uno de los elementos en turno, hasta llegar al elemento requerido. Para
muchas tareas, es conveniente visualizar un archivo como una serie de líneas de texto,
cada una compuesta por un número de caracteres y que termina con el carácter de fin de
línea. Un beneficio de esta forma de trabajo es la facilidad de transferir archivos entre
aplicaciones. Así se podría crear un archivo ejecutando un programa en Java y después
cargarlo en un procesador de palabras, editor de texto o correo electrónico.
Las clases de flujo están organizadas de la siguiente forma:
Reader
BufferedReader
InputStreamReader
FileReader
Writer
PrintWriter
FileWriter
24

25. Para procesar archivos se utilizan las clases BufferedReader y PrintWriter para leer y
escribir líneas de texto, y para la entrada que no provenga de archivos (desde el teclado
y páginas Web) también se utiliza InputSreamReader.
Los programas que utilizan archivos deben contener la instrucción: import java.io.*;
"Búfer" significa que, el software lee un gran trozo de datos del dispositivo de
almacenamiento externo y lo guarda en la RAM, de tal forma que invocaciones
sucesivas de los métodos que necesitan leer una pequeña cantidad de datos del
dispositivo de almacenamiento de archivos puedan obtener rápidamente los datos de la
RAM. Por lo tanto, un búfer actúa como un amortiguador entre el dispositivo de
almacenamiento y el programa.
La clase File
Esta clase ofrece la capacidad de manipular archivos y directorios en general.
No se utiliza para tener acceso a los datos dentro de los archivos.
Se necesita utilizar la instrucción: import java.io.*;
La mayoría de los sistemas operativos ofrecen una estructura jerárquica con una ruta
para avanzar a través de la misma, cuya forma es:
d:estructuraDeDatosJavaArchivosInventario.java
Ésta es una ruta estilo Windows que utiliza '' como separador. En un sistema UNIX se
utiliza como separador '/'. Si usted necesita escribir software para manipular rutas y que
funcione en cualquier sistema puede averiguar cúal es el separador de archivos haciendo
referencia a la constante de la cadena File.separator.
La ruta mostrada anteriormente es absoluta, empieza desde la parte superior del
directorio y lo lleva hasta el archivo. No obstante, a veces esto es irrelevante: sólo
necesitamos tratar con rutas que sean relativas al directorio actual. Por ejemplo, si nos
encontramos en el directorio Java, entonces la ruta de Inventario.java sería
ArchivosInventario.java.
Inicialmente debemos construir una instancia de la clase File proporcionando una
cadena. Una vez creada se puede utilizar. Considere la siguiente instrucción:
File archivo = new File ("c:estructuraDeDatosJavaArchivosInventario.java");
Como el caracter de escape '' es casualmente el mismo que el separador de archivos en
Window, se necesita decir que es simplemente un caracter normal de la cadena en vez
de tener un significado especial, por lo que hay que anteponerle un caracter de escape.
Así, representa a .
25

26. FUNCIONAMIENTO DEL PROGRAMA
El programa principal utiliza todas las características mencionadas en el artículo
presente, por lo que el modo de funcionamiento tiene basadas las características antes
mencionadas con la interfaz gráfica que permite una interacción con el usuario por
medio de ventanas, las mismas que despliegan la información, solicitando al usuario las
diferentes opciones que presenta, en cada cuadro de diálogo.
Por ejemplo, para el menú principal se tiene:
Si se escoge la primera opción, aparecerá otro menú mostrando lo siguiente:
26

27. En este existen las diferentes opciones de un menú general, por lo que si se selecciona
por ejemplo la opción 2:
aparecerá en orden los menús solicitando la información requerida:
 código que identificará a la canción
Para el código existe un parámetro que debe cumplirse, de lo contrario no se procederá
continuar con el programa y con esto no se almacenará lo que se ingrese; el parámetro
es de M[x][n] [n] [n]
Donde: x hace referencia a la inicial del tipo de canción inicial, ejemplo: Bailable
B; ClásicaC, etc., y
n es un dígito entero; por lo que se necesitan 3 dígitos
 el nombre de la canción
27

28.  el autor de la canción
 año de la canción
En este caso se debe cumplir que esté entre los años 1900 hasta el 2010.
 Este cuadro es para el
género más específico de la canción.
 Por último está el
tiempo de duración que en este caso está estimado por un valor double.
Al terminar podremos escoger la opción de guardado, que es la única manera de
almacenar los datos ingresados, escogiendo la opción 5:
28

29. y como demostración que se van almacenando una tras otra las canciones, se puede
abrir el documento de texto que es utilizado para este propósito.
Como se puede observar se encuentra almacenado al final del archivo, con lo que
concluye la explicación de almacenamiento.
Para búsqueda es un proceso de lectura que pide parámetros y para borrado igualmente,
por lo que hay que tener atención a qué es lo que se quiere buscar o eliminar.
CONCLUSIONES Y RECOMENDACIONES:
• Eclipse es un entorno de desarrollo integrado de código abierto
multiplataforma para desarrollar lo que el proyecto llama "Aplicaciones de
Cliente Enriquecido", opuesto a las aplicaciones "Cliente-liviano" basadas en
navegadores.
• Al realizar este programa, encontramos que existe diferentes tipos para expresar
las variables que vayamos a utilizar y a la vez debemos utilizar.
• Nos pudimos dar cuenta que el resultado del proyecto debería darnos con un
interfaz agradable con el usuario, para que se diferencien los objetivos señalados
29

30. • La visualización de todo el trabajo se basa específicamente en tres niveles de
objetos, para poder identificar aun más los comandos utilizados para este
propósito.
• Algunas especificaciones varían de acuerdo a lo solicitado por el usuario, como
son por ejemplo en las clases y tipos de datos a utilizarse para la implementación
del mismo.
• Para obtener el diagrama UML hay que tener en claro los conceptos de clases,
objetos, atributos y métodos.
• Hay que tener en cuenta la forma de elaborar los diagramas UML que
quisiéramos utilizar.
• Los diagramas que utilizamos son elaborado mediante herencias y por eso no
encontramos los atributos y métodos.
• En nuestro programa utilizamos el manejo de excepciones y archivos.
• Una excepción es un evento que ocurre durante la ejecución de un programa y
detiene el flujo normal de la secuencia de instrucciones de ese programa; en
otras palabras, una excepción es una condición anormal que surge en una
secuencia de código durante su ejecución.
• Cuando queremos preservar la información es necesario guardarlo en un
almacenamiento de tipo no volátil: este es el almacenamiento secundario
• .
• El SDK de Eclipse incluye las herramientas de desarrollo de Java, ofreciendo un
IDE con un compilador de Java interno y un modelo completo de los archivos
fuente de Java. Esto permite técnicas avanzadas de refactorización y análisis de
código.
BIBLIOGRAFIA:
Diagrama UML
• http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado
• http://tvdi.det.uvigo.es/~avilas/UML/node37.html
Eclipse
• http://es.wikipedia.org/wiki/Eclipse
Herencias
• http://www.webtaller.com/manual-java/herencia.php
30

31. • http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap
4_7_4
• http://www.webtaller.com/manual-java/this-super.php
• http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap
4_7_4
Interfaces
• http://www.webtaller.com/manual-java/this-super.php
• http://www.webtaller.com/manual-java/interfaces.php
• http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap
4_7_4
Variables y Métodos estáticos
• http://es.wikipedia.org/wiki/Lenguaje_Unificado_de_Modelado
• http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap
4_7_4
• http://www.scribd.com/doc/6724629/Clase-Archivo-Java
Integer
• http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap
4_7_4
Excepciones
• http://jcca007.iespana.es/codigosjava.htm
• http://es.wikipedia.org/wiki/Manejo_de_excepciones
• http://www.scribd.com/doc/6724629/Clase-Archivo-Java
• http://delfosis.uam.mx/~sgb/Archivos/Excepciones_y_archivos.html
Actualización de información
• http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap
4_7_4
Archivos de texto
• http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte4/cap4-7.html#Cap
4_7_4
31